X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Flib%2Fplatform%2Fsockets%2Ftcp.h;h=1dad499e5ea608947f576b25e39739dc1c3aa37e;hb=ebcedb051be7d8e1e19ecd3f0aa164baae252400;hp=ef9c418aaa82568d7b24008e0e8be5c487605add;hpb=cb2397e953b3f892b4206d5bb87968ca4cccbac8;p=deb_libcec.git

diff --git a/src/lib/platform/sockets/tcp.h b/src/lib/platform/sockets/tcp.h
index ef9c418..1dad499 100644
--- a/src/lib/platform/sockets/tcp.h
+++ b/src/lib/platform/sockets/tcp.h
@@ -33,28 +33,24 @@
 
 #include "socket.h"
 
-#if defined(__WINDOWS__)
-#include "../windows/os-tcp.h"
-#else
-#include "../posix/os-tcp.h"
-#endif
-
 using namespace std;
 
 namespace PLATFORM
 {
-  class CTcpSocket : public CSocket
+  class CTcpSocket : public CCommonSocket<tcp_socket_t>
   {
     public:
-      CTcpSocket(void) {};
+      CTcpSocket(const std::string &strHostname, uint16_t iPort) :
+        CCommonSocket<tcp_socket_t>(INVALID_SOCKET_VALUE, strHostname),
+        m_iPort(iPort) {}
+
       virtual ~CTcpSocket(void) {}
 
-      virtual bool Open(const CStdString &strHostname, uint16_t iPort, uint64_t nTimeout)
+      virtual bool Open(uint64_t iTimeoutMs = 0)
       {
         bool bReturn(false);
         struct addrinfo *address(NULL), *addr(NULL);
-        CLockObject lock(m_mutex);
-        if (!TcpResolveAddress(strHostname.c_str(), iPort, &m_iError, &address))
+        if (!TcpResolveAddress(m_strName.c_str(), m_iPort, &m_iError, &address))
         {
           m_strError = strerror(m_iError);
           return bReturn;
@@ -62,8 +58,8 @@ namespace PLATFORM
 
         for(addr = address; !bReturn && addr; addr = addr->ai_next)
         {
-          m_socket = TcpCreateSocket(addr, &m_iError, nTimeout);
-          if (m_socket != INVALID_SOCKET && m_socket != SOCKET_ERROR)
+          m_socket = TcpCreateSocket(addr, &m_iError, iTimeoutMs);
+          if (m_socket != INVALID_SOCKET_VALUE)
             bReturn = true;
           else
             m_strError = strerror(m_iError);
@@ -73,34 +69,104 @@ namespace PLATFORM
         return bReturn;
       }
 
+      virtual void Close(void)
+      {
+        TcpSocketClose(m_socket);
+        m_socket = INVALID_SOCKET_VALUE;
+      }
+
       virtual void Shutdown(void)
       {
-        CLockObject lock(m_mutex);
-        if (m_socket != INVALID_SOCKET && m_socket != SOCKET_ERROR)
-          TcpShutdownSocket(m_socket);
-        m_socket = INVALID_SOCKET;
-        m_strError = "";
+        TcpSocketShutdown(m_socket);
+        m_socket = INVALID_SOCKET_VALUE;
       }
 
-  protected:
-    virtual socket_t TcpCreateSocket(struct addrinfo* addr, int* iError, uint64_t iTimeout)
-    {
-      socket_t fdSock = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
-      if (fdSock == INVALID_SOCKET || fdSock == SOCKET_ERROR)
+      virtual ssize_t Write(void* data, size_t len)
       {
-        *iError = errno;
-        return (socket_t)SOCKET_ERROR;
+        return TcpSocketWrite(m_socket, &m_iError, data, len);
       }
 
-      if (!TcpConnectSocket(fdSock, addr, iError, iTimeout))
+      virtual ssize_t Read(void* data, size_t len, uint64_t iTimeoutMs = 0)
       {
-        SocketClose(fdSock);
-        return (socket_t)SOCKET_ERROR;
+        return TcpSocketRead(m_socket, &m_iError, data, len, iTimeoutMs);
       }
 
-      TcpSetNoDelay(fdSock);
+      virtual bool IsOpen(void)
+      {
+        return m_socket != INVALID_SOCKET_VALUE;
+      }
+
+    protected:
+      virtual tcp_socket_t TcpCreateSocket(struct addrinfo* addr, int* iError, uint64_t iTimeout)
+      {
+        tcp_socket_t fdSock = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
+        if (fdSock == INVALID_SOCKET_VALUE)
+        {
+          *iError = errno;
+          return (tcp_socket_t)INVALID_SOCKET_VALUE;
+        }
+
+        if (!TcpConnectSocket(fdSock, addr, iError, iTimeout))
+        {
+          TcpSocketClose(fdSock);
+          return (tcp_socket_t)INVALID_SOCKET_VALUE;
+        }
+
+        TcpSetNoDelay(fdSock);
+
+        return fdSock;
+      }
+
+      uint16_t   m_iPort;
+  };
+
+  class CTcpClientSocket : public CCommonSocket<tcp_socket_t>
+  {
+  public:
+    CTcpClientSocket(tcp_socket_t socket) :
+      CCommonSocket<tcp_socket_t>(socket, "tcpclient") {}
+
+    virtual ~CTcpClientSocket(void) {}
+
+    virtual bool Open(uint64_t iTimeoutMs = 0)
+    {
+      (void) iTimeoutMs;
+      return true;
+    }
 
-      return fdSock;
+    virtual void Close(void)
+    {
+      TcpSocketClose(m_socket);
+      m_socket = INVALID_SOCKET_VALUE;
     }
+
+    virtual void Shutdown(void)
+    {
+      TcpSocketShutdown(m_socket);
+      m_socket = INVALID_SOCKET_VALUE;
+    }
+
+    virtual ssize_t Write(void* data, size_t len)
+    {
+      return TcpSocketWrite(m_socket, &m_iError, data, len);
+    }
+
+    virtual ssize_t Read(void* data, size_t len, uint64_t iTimeoutMs = 0)
+    {
+      return TcpSocketRead(m_socket, &m_iError, data, len, iTimeoutMs);
+    }
+
+    virtual bool IsOpen(void)
+    {
+      return m_socket != INVALID_SOCKET_VALUE;
+    }
+  };
+
+  class CTcpConnection : public CProtectedSocket<CTcpSocket>
+  {
+  public:
+    CTcpConnection(const std::string &strHostname, uint16_t iPort) :
+      CProtectedSocket<CTcpSocket> (new CTcpSocket(strHostname, iPort)) {}
+    virtual ~CTcpConnection(void) {}
   };
 };