posixsocket.h

Go to the documentation of this file.

#pragma once
#ifndef POSIX_POSIXSOCKET_H
#define POSIX_POSIXSOCKET_H
//------------------------------------------------------------------------------
#include "core/refcounted.h"
#include "net/socket/ipaddress.h"
#include <sys/socket.h>
#include <netinet/tcp.h>
 
namespace Net
{
class Socket;
}
 
//------------------------------------------------------------------------------
namespace Posix
{
 
typedef int SOCKET;
 
class PosixSocket : public Core::RefCounted
{
    __DeclareClass(PosixSocket);
public:
    enum Protocol
    {
        TCP,            // a reliable TCP connection
        UDP,            // unreliable UDP connection
    };
 
    // return values
    enum Result
    {
        Error = 0,      // an error occured, call GetErrorCode() or GetErrorString() for more info
        Success,        // everything ok
        WouldBlock,     // operation on non-blocking socket is not complete
        Closed,         // connection has been gracefully closed
    };
 
    enum ErrorCode
    {
        ErrorNone,                   // no error occured
        ErrorUnknown,                // an "unknown" error occured     
        ErrorInterrupted,            // EINTR
    ErrorBrokenPipe,         // EPIPE
        ErrorPermissionDenied,       // EACCESS
        ErrorBadAddress,             // EFAULT
        ErrorInvalidArgument,        // EINVAL
        ErrorTooManyOpenFiles,       // EMFILE
        ErrorWouldBlock,             // EWOULDBLOCK
        ErrorInProgress,             // EINPROGRESS
        ErrorAlreadyInProgress,      // EALREADY
        ErrorNotASocket,             // ENOTSOCK
        ErrorDestAddrRequired,       // EDESTADDRREQ
        ErrorMsgTooLong,             // EMSGSIZE
        ErrorInvalidProtocol,        // EPROTOTYPE
        ErrorBadProtocolOption,      // ENOPROTOOPT
        ErrorProtocolNotSupported,   // WSEAPROTONOSUPPORT
        ErrorSocketTypeNotSupported, // ESOCKTNOSUPPORT
        ErrorOperationNotSupported,  // EOPNOTSUPP
        ErrorProtFamilyNotSupported, // EPFNOSUPPORT
        ErrorAddrFamilyNotSupported, // EAFNOSUPPORT
        ErrorAddrInUse,              // EADDRINUSE
        ErrorAddrNotAvailable,       // EADDRNOTAVAIL
        ErrorNetDown,                // ENETDOWN
        ErrorNetUnreachable,         // ENETUNREACH
        ErrorNetReset,               // ENETRESET
        ErrorConnectionAborted,      // ECONNABORTED
        ErrorConnectionReset,        // ECONNRESET
        ErrorNoBufferSpace,          // ENOBUFS
        ErrorIsConnected,            // EISCONN
        ErrorNotConnected,           // ENOTCONNECTED
        ErrorIsShutdown,             // ESHUTDOWN
        ErrorIsTimedOut,             // ETIMEDOUT
        ErrorConnectionRefused,      // ECONNREFUSED
        ErrorHostDown,               // EHOSTDOWN
        ErrorHostUnreachable,        // EHOSTUNREACH
        ErrorSystemNotReady,         // ESYSNOTREADY
        ErrorVersionNotSupported,    // EVERNOTSUPPORTED
        ErrorNotInitialized,         // ENOTINITIALISED
        ErrorDisconnecting,          // EDISCONN
        ErrorTypeNotFound,           // ETYPE_NOT_FOUND
        ErrorHostNotFound,           // EHOST_NOT_FOUND
        ErrorTryAgain,               // ETRY_AGAIN
        ErrorNoRecovery,             // ENO_RECOVERY
        ErrorNoData,                 // ENO_DATA
    };
 
    PosixSocket();
    virtual ~PosixSocket();
 
    bool Open(Protocol p);
    void Close();
    bool IsOpen() const;
    ErrorCode GetErrorCode() const;
    Util::String GetErrorString() const;
 
    void SetAddress(const Net::IpAddress& a);
    const Net::IpAddress& GetAddress() const;
    
    void SetBroadcast(bool b);
    bool GetBroadcast();
    void SetDontLinger(bool b);
    bool GetDontLinger();
    void SetKeepAlive(bool b);
    bool GetKeepAlive();
    void SetReUseAddr(bool b);
    bool GetReUseAddr();
    void SetNoDelay(bool b);
    bool GetNoDelay();
    void SetRecvBufSize(SizeT s);
    SizeT GetRecvBufSize();
    void SetSendBufSize(SizeT s);
    SizeT GetSendBufSize();
    void SetBlocking(bool b);
    bool GetBlocking() const;
    SizeT GetMaxMsgSize();
 
    bool Bind();
    bool IsBound() const;
    bool Listen();
    bool Accept(Ptr<Net::Socket>& outSocket);
    Result Connect();
    bool IsConnected();
    Result Send(const void* buf, SizeT numBytes, SizeT& bytesSent);
    bool HasRecvData();
    Result Recv(void* buf, SizeT bufSize, SizeT& bytesReceived);
    Result SendTo(const void* buf, SizeT numBytes, uint addr, ushort port, SizeT& bytesSent);
    Result RecvFrom(void* buf, SizeT bufSize, uint addr, ushort port, SizeT& bytesReceived);
 
private:
    friend class PosixIpAddress;
    friend class SysFunc;
 
    static void InitNetwork();
    void OpenWithExistingSocket(int s);
    void ClearError();
    void SetToLastSocketError();
    void SetSocketError(int wsaError);
    static ErrorCode SocketErrorToErrorCode(int wsaError);
    static ErrorCode HostErrorToErrorCode(int wsaError);
    static Util::String ErrorAsString(ErrorCode err);
    static Util::String SocketErrorToString(int wsaError);
    static Util::String HostErrorToString(int wsaError);
    void SetBoolOption(int optName, bool val);
    bool GetBoolOption(int optName);
    void SetIntOption(int optName, int val);
    int GetIntOption(int optName);
 
    static bool NetworkInitialized;
    ErrorCode error;
    SOCKET sock;
    Net::IpAddress addr;
    bool isBlocking;
    bool isBound;
};
 
//------------------------------------------------------------------------------
inline bool
PosixSocket::IsOpen() const
{
    return (0 != this->sock);
}
 
//------------------------------------------------------------------------------
inline bool
PosixSocket::IsBound() const
{
    return this->isBound;
}
 
//------------------------------------------------------------------------------
inline void
PosixSocket::SetAddress(const Net::IpAddress& a)
{
    this->addr = a;
}
 
//------------------------------------------------------------------------------
inline const Net::IpAddress&
PosixSocket::GetAddress() const
{
    return this->addr;
}
 
//------------------------------------------------------------------------------
inline PosixSocket::ErrorCode 
PosixSocket::GetErrorCode() const
{
  return this->error;
}
 
//------------------------------------------------------------------------------
inline void
PosixSocket::SetBroadcast(bool b)
{
    this->SetBoolOption(SO_BROADCAST, b);
}
 
//------------------------------------------------------------------------------
inline bool
PosixSocket::GetBroadcast()
{
    return this->GetBoolOption(SO_BROADCAST);
}
 
//------------------------------------------------------------------------------
inline void
PosixSocket::SetDontLinger(bool b)
{
    this->SetBoolOption(SO_LINGER, !b);
}
 
//------------------------------------------------------------------------------
inline bool
PosixSocket::GetDontLinger()
{
    return !this->GetBoolOption(SO_LINGER);
}
 
//------------------------------------------------------------------------------
inline void
PosixSocket::SetKeepAlive(bool b)
{
    this->SetBoolOption(SO_KEEPALIVE, b);
}
 
//------------------------------------------------------------------------------
inline bool
PosixSocket::GetKeepAlive()
{
    return this->GetBoolOption(SO_KEEPALIVE);
}
 
//------------------------------------------------------------------------------
inline void
PosixSocket::SetReUseAddr(bool b)
{
    this->SetBoolOption(SO_REUSEADDR, b);
}
 
//------------------------------------------------------------------------------
inline bool
PosixSocket::GetReUseAddr()
{
    return this->GetBoolOption(SO_REUSEADDR);
}
 
//------------------------------------------------------------------------------
inline void
PosixSocket::SetNoDelay(bool b)
{
    this->SetBoolOption(TCP_NODELAY, b);
}
 
//------------------------------------------------------------------------------
inline bool
PosixSocket::GetNoDelay()
{
    return this->GetBoolOption(TCP_NODELAY);
}
 
//------------------------------------------------------------------------------
inline void
PosixSocket::SetRecvBufSize(SizeT s)
{
    this->SetIntOption(SO_RCVBUF, s);
}
 
//------------------------------------------------------------------------------
inline SizeT
PosixSocket::GetRecvBufSize()
{
    return this->GetIntOption(SO_RCVBUF);
}
 
//------------------------------------------------------------------------------
inline void
PosixSocket::SetSendBufSize(SizeT s)
{
    this->SetIntOption(SO_SNDBUF, s);
}
 
//------------------------------------------------------------------------------
inline SizeT
PosixSocket::GetSendBufSize()
{
    return this->GetIntOption(SO_SNDBUF);
}
 
//------------------------------------------------------------------------------
inline SizeT
PosixSocket::GetMaxMsgSize()
{
    return 1500; // XXX: Revisit this.
    // return this->GetIntOption(SO_MAX_MSG_SIZE);
}
 
//------------------------------------------------------------------------------
inline bool
PosixSocket::GetBlocking() const
{
    return this->isBlocking;
}
 
} // namespace Posix
//------------------------------------------------------------------------------
#endif