Sockets/Socket.h

   1 /** \file Socket.h
   2  ** \date  2004-02-13
   3  ** \author grymse@alhem.net
   4 **/
   5 /*
   6 Copyright (C) 2004-2007  Anders Hedstrom
   7
   8 This software is made available under the terms of the GNU GPL.
   9
  10 If you would like to use this library in a closed-source application,
  11 a separate license agreement is available. For information about
  12 the closed-source license agreement for the C++ sockets library,
  13 please visit http://www.alhem.net/Sockets/license.html and/or
  14 email license@alhem.net.
  15
  16 This program is free software; you can redistribute it and/or
  17 modify it under the terms of the GNU General Public License
  18 as published by the Free Software Foundation; either version 2
  19 of the License, or (at your option) any later version.
  20
  21 This program is distributed in the hope that it will be useful,
  22 but WITHOUT ANY WARRANTY; without even the implied warranty of
  23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24 GNU General Public License for more details.
  25
  26 You should have received a copy of the GNU General Public License
  27 along with this program; if not, write to the Free Software
  28 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  29 */
  30 #ifndef _SOCKETS_Socket_H
  31 #define _SOCKETS_Socket_H
  32 #include "sockets-config.h"
  33
  34 #include <string>
  35 #include <vector>
  36 #include <list>
  37 #ifdef HAVE_OPENSSL
  38 #include <openssl/ssl.h>
  39 #endif
  40
  41 #include "socket_include.h"
  42 #include <time.h>
  43 #include "SocketAddress.h"
  44 #include "Thread.h"
  45
  46
  47 #ifdef SOCKETS_NAMESPACE
  48 namespace SOCKETS_NAMESPACE {
  49 #endif
  50
  51
  52 class ISocketHandler;
  53 class SocketAddress;
  54 class IFile;
  55
  56
  57 /** \defgroup basic Basic sockets */
  58 /** Socket base class.
  59         \ingroup basic */
  60 class Socket
  61 {
  62         friend class ISocketHandler;
  63 #ifdef ENABLE_DETACH
  64         /** Detached socket run thread.
  65                 \ingroup internal */
  66         class SocketThread : public Thread
  67         {
  68         public:
  69                 SocketThread(Socket *p);
  70                 ~SocketThread();
  71
  72                 void Run();
  73
  74         private:
  75                 Socket *GetSocket() const { return m_socket; }
  76                 SocketThread(const SocketThread& s) : m_socket(s.GetSocket()) {}
  77                 SocketThread& operator=(const SocketThread& ) { return *this; }
  78                 Socket *m_socket;
  79         };
  80 #endif // ENABLE_DETACH
  81
  82 #ifdef ENABLE_TRIGGERS
  83 public:
  84         /** Data pass class from source to destination. */
  85         class TriggerData
  86         {
  87         public:
  88                 TriggerData() : m_src(NULL) {}
  89                 virtual ~TriggerData() {}
  90
  91                 Socket *GetSource() const { return m_src; }
  92                 void SetSource(Socket *x) { m_src = x; }
  93
  94         private:
  95                 Socket *m_src;
  96         };
  97 #endif // ENABLE_TRIGGERS
  98
  99         /** Socket mode flags. */
 100 /*
 101         enum {
 102                 // Socket
 103                 SOCK_DEL =                      0x01, ///< Delete by handler flag
 104                 SOCK_CLOSE =                    0x02, ///< Close and delete flag
 105                 SOCK_DISABLE_READ =             0x04, ///< Disable checking for read events
 106                 SOCK_CONNECTED =                0x08, ///< Socket is connected (tcp/udp)
 107
 108                 SOCK_ERASED_BY_HANDLER =        0x10, ///< Set by handler before delete
 109                 // HAVE_OPENSSL
 110                 SOCK_ENABLE_SSL =               0x20, ///< Enable SSL for this TcpSocket
 111                 SOCK_SSL =                      0x40, ///< ssl negotiation mode (TcpSocket)
 112                 SOCK_SSL_SERVER =               0x80, ///< True if this is an incoming ssl TcpSocket connection
 113
 114                 // ENABLE_IPV6
 115                 SOCK_IPV6 =                     0x0100, ///< This is an ipv6 socket if this one is true
 116                 // ENABLE_POOL
 117                 SOCK_CLIENT =                   0x0200, ///< only client connections are pooled
 118                 SOCK_RETAIN =                   0x0400, ///< keep connection on close
 119                 SOCK_LOST =                     0x0800, ///< connection lost
 120
 121                 // ENABLE_SOCKS4
 122                 SOCK_SOCKS4 =                   0x1000, ///< socks4 negotiation mode (TcpSocket)
 123                 // ENABLE_DETACH
 124                 SOCK_DETACH =                   0x2000, ///< Socket ordered to detach flag
 125                 SOCK_DETACHED =                 0x4000, ///< Socket has been detached
 126                 // StreamSocket
 127                 STREAMSOCK_CONNECTING =         0x8000, ///< Flag indicating connection in progress
 128
 129                 STREAMSOCK_FLUSH_BEFORE_CLOSE = 0x010000L, ///< Send all data before closing (default true)
 130                 STREAMSOCK_CALL_ON_CONNECT =    0x020000L, ///< OnConnect will be called next ISocketHandler cycle if true
 131                 STREAMSOCK_RETRY_CONNECT =      0x040000L, ///< Try another connection attempt next ISocketHandler cycle
 132                 STREAMSOCK_LINE_PROTOCOL =      0x080000L, ///< Line protocol mode flag
 133
 134         };
 135 */
 136
 137 public:
 138         /** "Default" constructor */
 139         Socket(ISocketHandler&);
 140
 141         virtual ~Socket();
 142
 143         /** Socket class instantiation method. Used when a "non-standard" constructor
 144          * needs to be used for the socket class. Note: the socket class still needs
 145          * the "default" constructor with one ISocketHandler& as input parameter.
 146          */
 147         virtual Socket *Create() { return NULL; }
 148
 149         /** Returns reference to sockethandler that owns the socket.
 150         If the socket is detached, this is a reference to the slave sockethandler.
 151         */
 152         ISocketHandler& Handler() const;
 153
 154         /** Returns reference to sockethandler that owns the socket.
 155         This one always returns the reference to the original sockethandler,
 156         even if the socket is detached.
 157         */
 158         ISocketHandler& MasterHandler() const;
 159
 160         /** Called by ListenSocket after accept but before socket is added to handler.
 161          * CTcpSocket uses this to create its ICrypt member variable.
 162          * The ICrypt member variable is created by a virtual method, therefore
 163          * it can't be called directly from the CTcpSocket constructor.
 164          * Also used to determine if incoming HTTP connection is normal (port 80)
 165          * or ssl (port 443).
 166          */
 167         virtual void Init();
 168
 169         /** Create a socket file descriptor.
 170                 \param af Address family AF_INET / AF_INET6 / ...
 171                 \param type SOCK_STREAM / SOCK_DGRAM / ...
 172                 \param protocol "tcp" / "udp" / ... */
 173         SOCKET CreateSocket(int af,int type,const std::string& protocol = "");
 174
 175         /** Assign this socket a file descriptor created
 176                 by a call to socket() or otherwise. */
 177         void Attach(SOCKET s);
 178
 179         /** Return file descriptor assigned to this socket. */
 180         SOCKET GetSocket();
 181
 182         /** Close connection immediately - internal use.
 183                 \sa SetCloseAndDelete */
 184         virtual int Close();
 185
 186         /** Add file descriptor to sockethandler fd_set's. */
 187         void Set(bool bRead,bool bWrite,bool bException = true);
 188
 189         /** Returns true when socket file descriptor is valid
 190                 and socket is not about to be closed. */
 191         virtual bool Ready();
 192
 193         /** Returns pointer to ListenSocket that created this instance
 194          * on an incoming connection. */
 195         Socket *GetParent();
 196
 197         /** Used by ListenSocket to set parent pointer of newly created
 198          * socket instance. */
 199         void SetParent(Socket *);
 200
 201         /** Get listening port from ListenSocket<>. */
 202         virtual port_t GetPort();
 203
 204         /** Set socket non-block operation. */
 205         bool SetNonblocking(bool);
 206
 207         /** Set socket non-block operation. */
 208         bool SetNonblocking(bool, SOCKET);
 209
 210         /** Total lifetime of instance. */
 211         time_t Uptime();
 212
 213         /** Set address/port of last connect() call. */
 214         void SetClientRemoteAddress(SocketAddress&);
 215
 216         /** Get address/port of last connect() call. */
 217         std::auto_ptr<SocketAddress> GetClientRemoteAddress();
 218
 219         /** Common interface for SendBuf used by Tcp and Udp sockets. */
 220         virtual void SendBuf(const char *,size_t,int = 0);
 221
 222         /** Common interface for Send used by Tcp and Udp sockets. */
 223         virtual void Send(const std::string&,int = 0);
 224
 225         /** Outgoing traffic counter. */
 226         virtual uint64_t GetBytesSent(bool clear = false);
 227
 228         /** Incoming traffic counter. */
 229         virtual uint64_t GetBytesReceived(bool clear = false);
 230
 231         // LIST_TIMEOUT
 232
 233         /** Enable timeout control. 0=disable timeout check. */
 234         void SetTimeout(time_t secs);
 235
 236         /** Check timeout. \return true if time limit reached */
 237         bool Timeout(time_t tnow);
 238
 239         /** Used by ListenSocket. ipv4 and ipv6 */
 240         void SetRemoteAddress(SocketAddress&);
 241
 242         /** \name Event callbacks */
 243         //@{
 244
 245         /** Called when there is something to be read from the file descriptor. */
 246         virtual void OnRead();
 247         /** Called when there is room for another write on the file descriptor. */
 248         virtual void OnWrite();
 249         /** Called on socket exception. */
 250         virtual void OnException();
 251         /** Called before a socket class is deleted by the ISocketHandler. */
 252         virtual void OnDelete();
 253         /** Called when a connection has completed. */
 254         virtual void OnConnect();
 255         /** Called when an incoming connection has been completed. */
 256         virtual void OnAccept();
 257         /** Called when a complete line has been read and the socket is in
 258          * line protocol mode. */
 259         virtual void OnLine(const std::string& );
 260         /** Called on connect timeout (5s). */
 261         virtual void OnConnectFailed();
 262         /** Called when a client socket is created, to set socket options.
 263                 \param family AF_INET, AF_INET6, etc
 264                 \param type SOCK_STREAM, SOCK_DGRAM, etc
 265                 \param protocol Protocol number (tcp, udp, sctp, etc)
 266                 \param s Socket file descriptor
 267         */
 268         virtual void OnOptions(int family,int type,int protocol,SOCKET s) = 0;
 269         /** Connection retry callback - return false to abort connection attempts */
 270         virtual bool OnConnectRetry();
 271 #ifdef ENABLE_RECONNECT
 272         /** a reconnect has been made */
 273         virtual void OnReconnect();
 274 #endif
 275         /** TcpSocket: When a disconnect has been detected (recv/SSL_read returns 0 bytes). */
 276         virtual void OnDisconnect();
 277         /** Timeout callback. */
 278         virtual void OnTimeout();
 279         /** Connection timeout. */
 280         virtual void OnConnectTimeout();
 281         //@}
 282
 283         /** \name Socket mode flags, set/reset */
 284         //@{
 285         /** Set delete by handler true when you want the sockethandler to
 286                 delete the socket instance after use. */
 287         void SetDeleteByHandler(bool = true);
 288         /** Check delete by handler flag.
 289                 \return true if this instance should be deleted by the sockethandler */
 290         bool DeleteByHandler();
 291
 292         // LIST_CLOSE - conditional event queue
 293
 294         /** Set close and delete to terminate the connection. */
 295         void SetCloseAndDelete(bool = true);
 296         /** Check close and delete flag.
 297                 \return true if this socket should be closed and the instance removed */
 298         bool CloseAndDelete();
 299
 300         /** Return number of seconds since socket was ordered to close. \sa SetCloseAndDelete */
 301         time_t TimeSinceClose();
 302
 303         /** Ignore read events for an output only socket. */
 304         void DisableRead(bool x = true);
 305         /** Check ignore read events flag.
 306                 \return true if read events should be ignored */
 307         bool IsDisableRead();
 308
 309         /** Set connected status. */
 310         void SetConnected(bool = true);
 311         /** Check connected status.
 312                 \return true if connected */
 313         bool IsConnected();
 314
 315         /** Set flag indicating the socket is being actively deleted by the sockethandler. */
 316         void SetErasedByHandler(bool x = true);
 317         /** Get value of flag indicating socket is deleted by sockethandler. */
 318         bool ErasedByHandler();
 319
 320         //@}
 321
 322         /** \name Information about remote connection */
 323         //@{
 324         /** Returns address of remote end. */
 325         std::auto_ptr<SocketAddress> GetRemoteSocketAddress();
 326         /** Returns address of remote end: ipv4. */
 327         ipaddr_t GetRemoteIP4();
 328 #ifdef ENABLE_IPV6
 329         /** Returns address of remote end: ipv6. */
 330 #ifdef IPPROTO_IPV6
 331         struct in6_addr GetRemoteIP6();
 332 #endif
 333 #endif
 334         /** Returns remote port number: ipv4 and ipv6. */
 335         port_t GetRemotePort();
 336         /** Returns remote ip as string? ipv4 and ipv6. */
 337         std::string GetRemoteAddress();
 338         /** ipv4 and ipv6(not implemented) */
 339         std::string GetRemoteHostname();
 340         //@}
 341
 342         /** Returns local port number for bound socket file descriptor. */
 343         port_t GetSockPort();
 344         /** Returns local ipv4 address for bound socket file descriptor. */
 345         ipaddr_t GetSockIP4();
 346         /** Returns local ipv4 address as text for bound socket file descriptor. */
 347         std::string GetSockAddress();
 348 #ifdef ENABLE_IPV6
 349 #ifdef IPPROTO_IPV6
 350         /** Returns local ipv6 address for bound socket file descriptor. */
 351         struct in6_addr GetSockIP6();
 352         /** Returns local ipv6 address as text for bound socket file descriptor. */
 353         std::string GetSockAddress6();
 354 #endif
 355 #endif
 356         // --------------------------------------------------------------------------
 357         /** @name IP options
 358            When an ip or socket option is available on all of the operating systems
 359            I'm testing on (linux 2.4.x, _win32, macosx, solaris9 intel) they are not
 360            checked with an #ifdef below.
 361            This might cause a compile error on other operating systems. */
 362         // --------------------------------------------------------------------------
 363
 364         // IP options
 365         //@{
 366
 367         bool SetIpOptions(const void *p, socklen_t len);
 368         bool SetIpTOS(unsigned char tos);
 369         unsigned char IpTOS();
 370         bool SetIpTTL(int ttl);
 371         int IpTTL();
 372         bool SetIpHdrincl(bool x = true);
 373         bool SetIpMulticastTTL(int);
 374         int IpMulticastTTL();
 375         bool SetMulticastLoop(bool x = true);
 376         bool IpAddMembership(struct ip_mreq&);
 377         bool IpDropMembership(struct ip_mreq&);
 378
 379 #ifdef IP_PKTINFO
 380         bool SetIpPktinfo(bool x = true);
 381 #endif
 382 #ifdef IP_RECVTOS
 383         bool SetIpRecvTOS(bool x = true);
 384 #endif
 385 #ifdef IP_RECVTTL
 386         bool SetIpRecvTTL(bool x = true);
 387 #endif
 388 #ifdef IP_RECVOPTS
 389         bool SetIpRecvopts(bool x = true);
 390 #endif
 391 #ifdef IP_RETOPTS
 392         bool SetIpRetopts(bool x = true);
 393 #endif
 394 #ifdef IP_RECVERR
 395         bool SetIpRecverr(bool x = true);
 396 #endif
 397 #ifdef IP_MTU_DISCOVER
 398         bool SetIpMtudiscover(bool x = true);
 399 #endif
 400 #ifdef IP_MTU
 401         int IpMtu();
 402 #endif
 403 #ifdef IP_ROUTER_ALERT
 404         bool SetIpRouterAlert(bool x = true);
 405 #endif
 406 #ifdef LINUX
 407         bool IpAddMembership(struct ip_mreqn&);
 408 #endif
 409 #ifdef LINUX
 410         bool IpDropMembership(struct ip_mreqn&);
 411 #endif
 412         //@}
 413
 414         // SOCKET options
 415         /** @name Socket Options */
 416         //@{
 417
 418         bool SoAcceptconn();
 419         bool SetSoBroadcast(bool x = true);
 420         bool SetSoDebug(bool x = true);
 421         int SoError();
 422         bool SetSoDontroute(bool x = true);
 423         bool SetSoLinger(int onoff, int linger);
 424         bool SetSoOobinline(bool x = true);
 425         bool SetSoRcvlowat(int);
 426         bool SetSoSndlowat(int);
 427         bool SetSoRcvtimeo(struct timeval&);
 428         bool SetSoSndtimeo(struct timeval&);
 429         bool SetSoRcvbuf(int);
 430         int SoRcvbuf();
 431         bool SetSoSndbuf(int);
 432         int SoSndbuf();
 433         int SoType();
 434         bool SetSoReuseaddr(bool x = true);
 435         bool SetSoKeepalive(bool x = true);
 436
 437 #ifdef SO_BSDCOMPAT
 438         bool SetSoBsdcompat(bool x = true);
 439 #endif
 440 #ifdef SO_BINDTODEVICE
 441         bool SetSoBindtodevice(const std::string& intf);
 442 #endif
 443 #ifdef SO_PASSCRED
 444         bool SetSoPasscred(bool x = true);
 445 #endif
 446 #ifdef SO_PEERCRED
 447         bool SoPeercred(struct ucred& );
 448 #endif
 449 #ifdef SO_PRIORITY
 450         bool SetSoPriority(int);
 451 #endif
 452 #ifdef SO_RCVBUFFORCE
 453         bool SetSoRcvbufforce(int);
 454 #endif
 455 #ifdef SO_SNDBUFFORCE
 456         bool SetSoSndbufforce(int);
 457 #endif
 458 #ifdef SO_TIMESTAMP
 459         bool SetSoTimestamp(bool x = true);
 460 #endif
 461 #ifdef SO_NOSIGPIPE
 462         bool SetSoNosigpipe(bool x = true);
 463 #endif
 464         //@}
 465
 466         // TCP options in TcpSocket.h/TcpSocket.cpp
 467
 468
 469 #ifdef HAVE_OPENSSL
 470         /** @name SSL Support */
 471         //@{
 472         /** SSL client/server support - internal use. \sa TcpSocket */
 473         virtual void OnSSLConnect();
 474         /** SSL client/server support - internal use. \sa TcpSocket */
 475         virtual void OnSSLAccept();
 476         /** SSL negotiation failed for client connect. */
 477         virtual void OnSSLConnectFailed();
 478         /** SSL negotiation failed for server accept. */
 479         virtual void OnSSLAcceptFailed();
 480         /** new SSL support */
 481         virtual bool SSLNegotiate();
 482         /** Check if SSL is Enabled for this TcpSocket.
 483                 \return true if this is a TcpSocket with SSL enabled */
 484         bool IsSSL();
 485         /** Enable SSL operation for a TcpSocket. */
 486         void EnableSSL(bool x = true);
 487         /** Still negotiating ssl connection.
 488                 \return true if ssl negotiating is still in progress */
 489         bool IsSSLNegotiate();
 490         /** Set flag indicating ssl handshaking still in progress. */
 491         void SetSSLNegotiate(bool x = true);
 492         /** OnAccept called with SSL Enabled.
 493                 \return true if this is a TcpSocket with an incoming SSL connection */
 494         bool IsSSLServer();
 495         /** Set flag indicating that this is a TcpSocket with incoming SSL connection. */
 496         void SetSSLServer(bool x = true);
 497         /** SSL; Get pointer to ssl context structure. */
 498         virtual SSL_CTX *GetSslContext() { return NULL; }
 499         /** SSL; Get pointer to ssl structure. */
 500         virtual SSL *GetSsl() { return NULL; }
 501         //@}
 502 #endif // HAVE_OPENSSL
 503
 504 #ifdef ENABLE_IPV6
 505         /** Enable ipv6 for this socket. */
 506         void SetIpv6(bool x = true);
 507         /** Check ipv6 socket.
 508                 \return true if this is an ipv6 socket */
 509         bool IsIpv6();
 510 #endif
 511
 512 #ifdef ENABLE_POOL
 513         /** @name Connection Pool */
 514         //@{
 515         /** Client = connecting TcpSocket. */
 516         void SetIsClient();
 517         /** Socket type from socket() call. */
 518         void SetSocketType(int x);
 519         /** Socket type from socket() call. */
 520         int GetSocketType();
 521         /** Protocol type from socket() call. */
 522         void SetSocketProtocol(const std::string& x);
 523         /** Protocol type from socket() call. */
 524         const std::string& GetSocketProtocol();
 525         /** Instruct a client socket to stay open in the connection pool after use.
 526                 If you have connected to a server using tcp, you can call SetRetain
 527                 to leave the connection open after your socket instance has been deleted.
 528                 The next connection you make to the same server will reuse the already
 529                 opened connection, if it is still available.
 530         */
 531         void SetRetain();
 532         /** Check retain flag.
 533                 \return true if the socket should be moved to connection pool after use */
 534         bool Retain();
 535         /** Connection lost - error while reading/writing from a socket - TcpSocket only. */
 536         void SetLost();
 537         /** Check connection lost status flag, used by TcpSocket only.
 538                 \return true if there was an error while r/w causing the socket to close */
 539         bool Lost();
 540         /** Copy connection parameters from sock. */
 541         void CopyConnection(Socket *sock);
 542         //@}
 543 #endif // ENABLE_POOL
 544
 545 #ifdef ENABLE_SOCKS4
 546         /** \name Socks4 support */
 547         //@{
 548         /** Socks4 client support internal use. \sa TcpSocket */
 549         virtual void OnSocks4Connect();
 550         /** Socks4 client support internal use. \sa TcpSocket */
 551         virtual void OnSocks4ConnectFailed();
 552         /** Socks4 client support internal use. \sa TcpSocket */
 553         virtual bool OnSocks4Read();
 554         /** Called when the last write caused the tcp output buffer to
 555          * become empty. */
 556         /** socket still in socks4 negotiation mode */
 557         bool Socks4();
 558         /** Set flag indicating Socks4 handshaking in progress */
 559         void SetSocks4(bool x = true);
 560
 561         /** Set socks4 server host address to use */
 562         void SetSocks4Host(ipaddr_t a);
 563         /** Set socks4 server hostname to use. */
 564         void SetSocks4Host(const std::string& );
 565         /** Socks4 server port to use. */
 566         void SetSocks4Port(port_t p);
 567         /** Provide a socks4 userid if required by the socks4 server. */
 568         void SetSocks4Userid(const std::string& x);
 569         /** Get the ip address of socks4 server to use.
 570                 \return socks4 server host address */
 571         ipaddr_t GetSocks4Host();
 572         /** Get the socks4 server port to use.
 573                 \return socks4 server port */
 574         port_t GetSocks4Port();
 575         /** Get socks4 userid.
 576                 \return Socks4 userid */
 577         const std::string& GetSocks4Userid();
 578         //@}
 579 #endif // ENABLE_SOCKS4
 580
 581 #ifdef ENABLE_RESOLVER
 582         /** \name Asynchronous Resolver */
 583         //@{
 584         /** Request an asynchronous dns resolution.
 585                 \param host hostname to be resolved
 586                 \param port port number passed along for the ride
 587                 \return Resolve ID */
 588         int Resolve(const std::string& host,port_t port = 0);
 589 #ifdef ENABLE_IPV6
 590         int Resolve6(const std::string& host, port_t port = 0);
 591 #endif
 592         /** Callback returning a resolved address.
 593                 \param id Resolve ID from Resolve call
 594                 \param a resolved ip address
 595                 \param port port number passed to Resolve */
 596         virtual void OnResolved(int id,ipaddr_t a,port_t port);
 597 #ifdef ENABLE_IPV6
 598         virtual void OnResolved(int id,in6_addr& a,port_t port);
 599 #endif
 600         /** Request asynchronous reverse dns lookup.
 601                 \param a in_addr to be translated */
 602         int Resolve(ipaddr_t a);
 603 #ifdef ENABLE_IPV6
 604         int Resolve(in6_addr& a);
 605 #endif
 606         /** Callback returning reverse resolve results.
 607                 \param id Resolve ID
 608                 \param name Resolved hostname */
 609         virtual void OnReverseResolved(int id,const std::string& name);
 610         /** Callback indicating failed dns lookup.
 611                 \param id Resolve ID */
 612         virtual void OnResolveFailed(int id);
 613         //@}
 614 #endif  // ENABLE_RESOLVER
 615
 616 #ifdef ENABLE_DETACH
 617         /** \name Thread Support */
 618         //@{
 619         /** Callback fires when a new socket thread has started and this
 620                 socket is ready for operation again.
 621                 \sa ResolvSocket */
 622         virtual void OnDetached();
 623
 624         // LIST_DETACH
 625
 626         /** Internal use. */
 627         void SetDetach(bool x = true);
 628         /** Check detach flag.
 629                 \return true if the socket should detach to its own thread */
 630         bool IsDetach();
 631
 632         /** Internal use. */
 633         void SetDetached(bool x = true);
 634         /** Check detached flag.
 635                 \return true if the socket runs in its own thread. */
 636         const bool IsDetached() const;
 637         /** Order this socket to start its own thread and call OnDetached
 638                 when ready for operation. */
 639         bool Detach();
 640         /** Store the slave sockethandler pointer. */
 641         void SetSlaveHandler(ISocketHandler *);
 642         /** Create new thread for this socket to run detached in. */
 643         void DetachSocket();
 644         //@}
 645 #endif // ENABLE_DETACH
 646
 647         /** Write traffic to an IFile. Socket will not delete this object. */
 648         void SetTrafficMonitor(IFile *p) { m_traffic_monitor = p; }
 649
 650 #ifdef ENABLE_TRIGGERS
 651         /** \name Triggers */
 652         //@{
 653         /** Subscribe to trigger id. */
 654         void Subscribe(int id);
 655         /** Unsubscribe from trigger id. */
 656         void Unsubscribe(int id);
 657         /** Trigger callback, with data passed from source to destination. */
 658         virtual void OnTrigger(int id, const TriggerData& data);
 659         /** Trigger cancelled because source has been deleted (as in delete). */
 660         virtual void OnCancelled(int id);
 661         //@}
 662 #endif
 663
 664 protected:
 665         /** default constructor not available */
 666         Socket() : m_handler(m_handler) {}
 667         /** copy constructor not available */
 668         Socket(const Socket& s) : m_handler(s.m_handler) {}
 669
 670         /** assignment operator not available. */
 671         Socket& operator=(const Socket& ) { return *this; }
 672
 673         /** All traffic will be written to this IFile, if set. */
 674         IFile *GetTrafficMonitor() { return m_traffic_monitor; }
 675
 676 //      unsigned long m_flags; ///< boolean flags, replacing old 'bool' members
 677
 678 private:
 679         ISocketHandler& m_handler; ///< Reference of ISocketHandler in control of this socket
 680         SOCKET m_socket; ///< File descriptor
 681         bool m_bDel; ///< Delete by handler flag
 682         bool m_bClose; ///< Close and delete flag
 683         time_t m_tCreate; ///< Time in seconds when this socket was created
 684         Socket *m_parent; ///< Pointer to ListenSocket class, valid for incoming sockets
 685         bool m_b_disable_read; ///< Disable checking for read events
 686         bool m_connected; ///< Socket is connected (tcp/udp)
 687         bool m_b_erased_by_handler; ///< Set by handler before delete
 688         time_t m_tClose; ///< Time in seconds when ordered to close
 689         std::auto_ptr<SocketAddress> m_client_remote_address; ///< Address of last connect()
 690         std::auto_ptr<SocketAddress> m_remote_address; ///< Remote end address
 691         IFile *m_traffic_monitor;
 692         time_t m_timeout_start; ///< Set by SetTimeout
 693         time_t m_timeout_limit; ///< Defined by SetTimeout
 694
 695 #ifdef _WIN32
 696 static  WSAInitializer m_winsock_init; ///< Winsock initialization singleton class
 697 #endif
 698
 699 #ifdef HAVE_OPENSSL
 700         bool m_b_enable_ssl; ///< Enable SSL for this TcpSocket
 701         bool m_b_ssl; ///< ssl negotiation mode (TcpSocket)
 702         bool m_b_ssl_server; ///< True if this is an incoming ssl TcpSocket connection
 703 #endif
 704
 705 #ifdef ENABLE_IPV6
 706         bool m_ipv6; ///< This is an ipv6 socket if this one is true
 707 #endif
 708
 709 #ifdef ENABLE_POOL
 710         int m_socket_type; ///< Type of socket, from socket() call
 711         std::string m_socket_protocol; ///< Protocol, from socket() call
 712         bool m_bClient; ///< only client connections are pooled
 713         bool m_bRetain; ///< keep connection on close
 714         bool m_bLost; ///< connection lost
 715 #endif
 716
 717 #ifdef ENABLE_SOCKS4
 718         bool m_bSocks4; ///< socks4 negotiation mode (TcpSocket)
 719         ipaddr_t m_socks4_host; ///< socks4 server address
 720         port_t m_socks4_port; ///< socks4 server port number
 721         std::string m_socks4_userid; ///< socks4 server usedid
 722 #endif
 723
 724 #ifdef ENABLE_DETACH
 725         bool m_detach; ///< Socket ordered to detach flag
 726         bool m_detached; ///< Socket has been detached
 727         SocketThread *m_pThread; ///< Detach socket thread class pointer
 728         ISocketHandler *m_slave_handler; ///< Actual sockethandler while detached
 729 #endif
 730 };
 731
 732 #ifdef SOCKETS_NAMESPACE
 733 }
 734 #endif
 735
 736
 737 #endif // _SOCKETS_Socket_H
 738