added suport for C-Strings in core class

Leandro Cerencio
1 parent 95926262
Showing 4 changed files with 76 additions and 65 deletions Show diff stats
.gitignore
src/lib/socket.cpp
src/lib/socket.h
src/utils/tcptunnel.cpp
@@ -0,0 +1 @@
+./build*/
@@ -11,7 +11,6 @@
 #include "socket.h"
 // TODO Remover Message Buffer
-const int lemoce::ClientSocket::MESSAGE_BUFFER = 8192;
 int lemoce::ServerSocket::BACKLOG = 512;
 lemoce::Socket::Socket()
@@ -50,12 +49,17 @@ void lemoce::Socket::close()
 }
-lemoce::ClientSocket::ClientSocket() { }
-
+lemoce::ClientSocket::ClientSocket()
+{
+  bufferSize = 8192;
+}
-lemoce::ClientSocket::ClientSocket(std::string remote, int port):
-  lemoce::Socket{}, remotePort(port), remoteHost{remote} { }
+lemoce::ClientSocket::ClientSocket(std::string remote, int port): ClientSocket{}
+{
+  remotePort = port;
+  remoteHost = remote;
+}
 void lemoce::ClientSocket::connect()
 {
@@ -88,30 +92,14 @@ void lemoce::ClientSocket::connect()
   localPort = lPort;
 }
-// TODO deletar essa ou de baixo
 std::unique_ptr<std::string> lemoce::ClientSocket::read()
 {
-  char chararray[MESSAGE_BUFFER + 1];
+  char chararray[bufferSize];
   std::ostringstream buffer;
   int nread;
-  while (((nread = ::recv(getFd(), chararray, MESSAGE_BUFFER, 0)) < 0))
-    {
-      if (errno == EINTR)
-        {
-          continue;
-        }
-      else
-        {
-          throw new SocketException{errno};
-        }
-    }
-
-  if (nread < MESSAGE_BUFFER)
-    {
-      chararray[nread] = '\0';
-    }
-  
+  read(chararray, bufferSize);
+    
   buffer << chararray;
   std::unique_ptr<std::string> result{new std::string{buffer.str()}};
@@ -119,49 +107,52 @@ std::unique_ptr&lt;std::string&gt; lemoce::ClientSocket::read()
   return result;
 }
-// TODO Modificar para aceitar array de bytes
-std::unique_ptr<std::string> lemoce::ClientSocket::read(const size_t n)
+int lemoce::ClientSocket::read(char msg[], const size_t n)
 {
-  std::ostringstream buffer;
-
+  size_t nleft;
   ssize_t nread;
+  char *ptr;
-  size_t left = n;
-  char chararray[n];
-  char * ptr = chararray;
-  
-  while (left > 0)
+  ptr = msg;
+  nleft = n;
+
+  while (nleft > 0)
     {
       if ((nread = ::recv(getFd(), ptr, n, 0)) < 0)
         {
           if (errno == EINTR)
-            nread = 0;
+            {
+              nread = 0;
+              continue;
+            }
           else
-            throw new SocketException{errno};
+            treatSocketError(false);
         }
-      else if (nread == 0)
-        break;
-      left -= nread;
+      nleft -= nread;
       ptr = ptr + nread;
+      break;
     }
-  buffer << chararray;
+  if (nleft > 0)
+    {
+      msg[n - nleft] = '\0';
+    }
-  std::unique_ptr<std::string> result{new std::string{buffer.str()}};
-  
-  return std::move(result);
+  return (n - nleft);
 }
-
 // TODO Modificar para array de bytes
 void lemoce::ClientSocket::write(const std::string& message)
 {
+  write(message.c_str(), message.size());
+}
-  size_t nleft = message.size();
-  const char * ptr = message.c_str();
-
+void lemoce::ClientSocket::write(const char * msg, size_t n)
+{
+  size_t nleft = n;
   ssize_t nwritten = nleft;
+  const char * ptr = msg;
   while (nleft > 0)
     {
@@ -170,11 +161,11 @@ void lemoce::ClientSocket::write(const std::string&amp; message)
           if (nwritten < 0 && errno == EINTR)
             nwritten = 0;
           else
-            throw new SocketException{errno};
+            treatSocketError(false);
         }
       nleft -= nwritten;
       ptr += nwritten;
-    }
+    }  
 }
 void lemoce::ClientSocket::setRemoteHost(std::string rHost)
@@ -217,6 +208,17 @@ int lemoce::ClientSocket::getLocalPort() const
   return localPort;
 }
+void lemoce::ClientSocket::setBufferSize(int size)
+{
+  bufferSize = size;
+}
+
+int lemoce::ClientSocket::getBufferSize() const
+{
+  return bufferSize;
+}
+
+
 lemoce::ServerSocket::ServerSocket(int lPort):
   lemoce::Socket{}, localPort(lPort) { }
@@ -42,15 +42,18 @@ namespace lemoce {
     std::string getLocalHost() const;
     void setLocalPort(int);
     int getLocalPort() const;
+    void setBufferSize(int);
+    int getBufferSize() const;
     void connect();
     std::unique_ptr<std::string> read();
-    std::unique_ptr<std::string> read(const size_t n);
+    int read(char msg[], const size_t n);
     void write(const std::string& message);
+    void write(const char * msg, const size_t n);
   private:
-    static const int MESSAGE_BUFFER;
+    int bufferSize;
     void fillLocalHostPort();
     std::string remoteHost; //!< Brief host do servidor
@@ -13,6 +13,9 @@
 #include "socket.h"
+const int MESSAGE_BUFFER = 8096;
+
+
 void threadManager(std::list<std::pair<std::shared_ptr<std::atomic<bool>>, std::unique_ptr<std::thread>>> & threads)
 {
   std::cout << "iniciei gerenciador de threads" << std::endl;
@@ -30,7 +33,7 @@ void threadManager(std::list&lt;std::pair&lt;std::shared_ptr&lt;std::atomic&lt;bool&gt;&gt;, std::
               (it->second)->join();
               (it->second).reset();
               it = threads.erase(it);
-              std::cout << "removi thread inutilizada " << (i+1) << std::endl;
+              // std::cout << "removi thread inutilizada " << (i+1) << std::endl;
             }
           else
             {
@@ -43,11 +46,14 @@ void threadManager(std::list&lt;std::pair&lt;std::shared_ptr&lt;std::atomic&lt;bool&gt;&gt;, std::
 void tunnelingTask(std::unique_ptr<lemoce::ClientSocket> server_ptr,
                    std::unique_ptr<lemoce::ClientSocket> client_ptr,
+                   std::unique_ptr<char []> buffer,
                    std::shared_ptr<std::atomic<bool>> done)
 {
   lemoce::ClientSocket server = *server_ptr;
   lemoce::ClientSocket client = *client_ptr;
+  char * charbuf;
+  charbuf = static_cast<char *>(buffer.get());
   try
     {
@@ -55,31 +61,27 @@ void tunnelingTask(std::unique_ptr&lt;lemoce::ClientSocket&gt; server_ptr,
       while(!server.isClosed())
         {
-          std::unique_ptr<std::string> incomingMessage = client.read();
-          if ((*incomingMessage).size() == 0)
+          int len = client.read(charbuf, MESSAGE_BUFFER);
+          if (len == 0)
             {
               server.close();
               client.close();
               break;
             }
-          std::cout << " ==> " << (*incomingMessage) << std::endl;
-
-          std::string * tmpMessage = incomingMessage.get();
-                  
-          server.write((*tmpMessage));
-          std::cout << (*tmpMessage) << " ==>" << std::endl;
-          std::unique_ptr<std::string> responseMessage = server.read();
-          if ((*responseMessage).size() == 0)
+          //std::cout << " ==> " << buffer << std::endl;
+
+          server.write(charbuf, len);
+          // std::cout << (*tmpMessage) << " ==>" << std::endl;
+          len = server.read(charbuf, MESSAGE_BUFFER);
+          if (len == 0)
             {
               server.close();
               client.close();
               break;
             }
-          std::cout << (*responseMessage) << " <==" << std::endl;
+          //std::cout << buffer << " <==" << std::endl;
-          tmpMessage = responseMessage.get();
-          client.write((*tmpMessage));
-          std::cout << " <== " << (*tmpMessage) <<  std::endl;
+          client.write(charbuf, len);
         }
     }
   catch (lemoce::SocketException & ex)
@@ -128,6 +130,8 @@ int main(int argc, char *argv[])
           std::unique_ptr<lemoce::ClientSocket> client_ptr{new lemoce::ClientSocket{}};
           std::unique_ptr<lemoce::ClientSocket> remoteClient_ptr;
+          std::unique_ptr<char []> buffer{new char[MESSAGE_BUFFER]};
+
           try
             {
               server.accept((*client_ptr));
@@ -154,6 +158,7 @@ int main(int argc, char *argv[])
             {
               tunnelingTask, std::move(remoteClient_ptr),
               std::move(client_ptr),
+              std::move(buffer),
               done
             }};