Implemented proceed of TcpSession

drclaws · drclaws · commit b761416c0fac · 2020-11-01T01:10:45.000+10:00
diff --git a/server/Server.cpp b/server/Server.cpp
@@ -342,13 +342,17 @@ namespace simpleApp
                             case session_status::proceed_send_fail:
                                 msg = std::string("SEND failed");
                                 break;
-                            case session_status::proceed_udp_wrong_header:
+                            case session_status::proceed_wrong_header:
                                 msg = std::string("Received message with wrong header");
                                 break;
                             case session_status::proceed_unknown_fd:
                                 msg = std::string("Unknown fd connected");
                                 break;
 
+                            case session_status::proceed_tcp_wrong_size:
+                                msg = std::string("Receive message has wrong size");
+                                break;
+
                             case session_status::proceed_udp_false_timeout:
                             case session_status::proceed_udp_socket_was_closed:
                                 break;
diff --git a/server/TcpSession.cpp b/server/TcpSession.cpp
@@ -14,11 +14,13 @@
 
 #include <simple_lib/common.h>
 
+#include "message.h"
+
 namespace simpleApp
 {
     TcpSession::TcpSession(int& epollfd) : ClientSession(epollfd, "TCP")
     {
-        //TODO
+        
     }
 
     session_result TcpSession::init(socket_t masterSocket, uint16_t port)
@@ -68,7 +70,36 @@ namespace simpleApp
 
     session_result TcpSession::proceed(struct epoll_event& epoll_event)
     {
-        // TODO
-        return session_result {session_status::proceed_msg_send, 0};
+        uint8_t buffer[MESSAGE_MAX_BUFFER];
+        auto len = recv(this->_socket, buffer, MESSAGE_MAX_BUFFER, 0);
+        if (len == -1)
+            return session_result {session_status::proceed_recv_fail, errno};
+        else if (len == 0)
+        {
+            this->sessionClose();
+            return session_result {session_status::proceed_disconnect};
+        }
+        else if (len <= sizeof(msg_headers))
+        {
+            const msg_headers buff = msg_headers::incorrect_msg;
+            send(this->_socket, &buff, sizeof(buff), 0);
+            return session_result {session_status::proceed_tcp_wrong_size};
+        }
+        
+        if(*reinterpret_cast<msg_headers*>(buffer) != msg_headers::client_msg)
+        {
+            const msg_headers buff = msg_headers::incorrect_msg;
+            send(this->_socket, &buff, sizeof(buff), 0);
+            return session_result {session_status::proceed_wrong_header};
+        }
+        
+        uint8_t buff[MESSAGE_MAX_BUFFER];
+                    
+        auto sendLen = proceedMsg(buffer, len, buff);
+
+        if (send(this->_socket, buff, sendLen, 0) == -1)
+            return session_result {session_status::proceed_send_fail, errno};
+
+        return session_result {session_status::proceed_msg_send};
     }
 }
diff --git a/server/UdpSession.cpp b/server/UdpSession.cpp
@@ -16,14 +16,15 @@
 
 #include <unistd.h>
 
-#include <simple_lib/message.h>
 #include <simple_lib/common.h>
 
+#include "message.h"
+
 namespace simpleApp
 {
     UdpSession::UdpSession(int& epollfd) : ClientSession(epollfd, "UDP")
     {
-        // TODO
+        
     }
 
     UdpSession::~UdpSession()
@@ -215,7 +216,7 @@ namespace simpleApp
 
             auto sendMsgError = [this]()
             {
-                const msg_headers header = msg_headers::err_server_msg;
+                const msg_headers header = msg_headers::incorrect_msg;
                 send(this->_socket, &header, sizeof(msg_headers), 0);
             };
 
@@ -234,7 +235,7 @@ namespace simpleApp
                 if (!(static_cast<header_base_type>(header) & static_cast<header_base_type>(msg_headers::sender_client)))
                 {
                     sendMsgError();
-                    return session_result {session_status::proceed_udp_wrong_header};
+                    return session_result {session_status::proceed_wrong_header};
                 }
                 
                 if (len == sizeof(msg_headers))
@@ -259,30 +260,23 @@ namespace simpleApp
 
                     default:
                         sendMsgError();
-                        return session_result {session_status::proceed_udp_wrong_header};
+                        return session_result {session_status::proceed_wrong_header};
                     };
                 }
                 else if (header == msg_headers::client_msg)
                 {
-                    // TODO replace this with required logic
                     uint8_t buff[MESSAGE_MAX_BUFFER];
                     
-                    const char* buff = "DELIVERED";
-                    const msg_headers buffHeader = msg_headers::server_msg;
+                    auto sendLen = proceedMsg(msgBuff, len, buff);
 
-                    this->timerReset();
-
-                    std::memcpy(buff, &buffHeader, sizeof(buffHeader));
-                    std::memcpy(buff + static_cast<ptrdiff_t>(sizeof(buffHeader)), buff, sizeof("DELIVERED"));
-                    
-                    if (send(this->_socket, buff, sizeof(buffHeader) + sizeof("DELIVERED"), 0) == -1)
+                    if (send(this->_socket, buff, sendLen, 0) == -1)
                         return session_result {session_status::proceed_send_fail, errno};
                     return session_result {session_status::proceed_msg_send};
                 }
                 else
                 {
                     sendMsgError();
-                    return session_result {session_status::proceed_udp_wrong_header};
+                    return session_result {session_status::proceed_wrong_header};
                 }
             }
         }
diff --git a/server/message.cpp b/server/message.cpp
@@ -0,0 +1,22 @@
+#include "message.h"
+
+#include <string>
+#include <cstring>
+
+#include <simple_lib/common.h>
+
+namespace simpleApp
+{
+    ssize_t proceedMsg(uint8_t* in, ssize_t len, uint8_t* out)
+    {
+        // TODO replace this with required logic
+        const msg_headers buffHeader = msg_headers::server_msg;
+        const char* msg = "DELIVERED";
+        const ssize_t size = sizeof("DELIVERED");
+
+        std::memcpy(out, &buffHeader, sizeof(buffHeader));
+        std::memcpy(out + static_cast<ptrdiff_t>(sizeof(buffHeader)), msg, size);
+
+        return sizeof(buffHeader) + size;
+    }
+}
diff --git a/server/message.h b/server/message.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+
+namespace simpleApp
+{
+    ssize_t proceedMsg(uint8_t* in, ssize_t len, uint8_t* out);
+}
diff --git a/server/session_result.h b/server/session_result.h
@@ -20,9 +20,11 @@ namespace simpleApp
         proceed_recv_fail,
         proceed_send_fail,
         proceed_unknown_fd,
+        proceed_wrong_header,
+
+        proceed_tcp_wrong_size,
 
         proceed_udp_timer_fail,
-        proceed_udp_wrong_header,
         proceed_udp_timeout,
         proceed_udp_false_timeout,
         proceed_udp_client_timeout,
diff --git a/simple_lib/include/simple_lib/common.h b/simple_lib/include/simple_lib/common.h
@@ -5,12 +5,12 @@
 namespace simpleApp
 {
     const unsigned int WAIT_TIMEOUT_SEC = 15;
-
-    /// Message headers.
-    /// TCP-sessions use only "Data proceeding" group.
+    const size_t MESSAGE_MAX_BUFFER = 1000;
 
     typedef uint8_t header_base_type;
 
+    /// Message headers.
+    /// TCP-sessions use only "Data proceeding" group.
     enum class msg_headers : header_base_type 
     {
         // Header flags
@@ -46,7 +46,7 @@ namespace simpleApp
         // Data proceeding (TCP possible)
         client_msg =            sender_client | message,
         server_msg =            sender_server | message,
-        err_server_msg =        sender_server | message | error     // Error in client message
+        incorrect_msg =        sender_server | message | error     // Error in client message
     };
 
     typedef int socket_t;
diff --git a/simple_lib/include/simple_lib/message.h b/simple_lib/include/simple_lib/message.h

Original file line number	Diff line number	Diff line change
`@@ -16,14 +16,15 @@`
`16`	`16`
`17`	`17`	`#include <unistd.h>`
`18`	`18`
`19`		`-#include <simple_lib/message.h>`
`20`	`19`	`#include <simple_lib/common.h>`
`21`	`20`
	`21`	`+#include "message.h"`
	`22`	`+`
`22`	`23`	`namespace simpleApp`
`23`	`24`	`{`
`24`	`25`	`UdpSession::UdpSession(int& epollfd) : ClientSession(epollfd, "UDP")`
`25`	`26`	`{`
`26`		`- // TODO`
	`27`	`+`
`27`	`28`	`}`
`28`	`29`
`29`	`30`	`UdpSession::~UdpSession()`
`@@ -215,7 +216,7 @@ namespace simpleApp`
`215`	`216`
`216`	`217`	`auto sendMsgError = [this]()`
`217`	`218`	`{`
`218`		`- const msg_headers header = msg_headers::err_server_msg;`
	`219`	`+ const msg_headers header = msg_headers::incorrect_msg;`
`219`	`220`	`send(this->_socket, &header, sizeof(msg_headers), 0);`
`220`	`221`	`};`
`221`	`222`
`@@ -234,7 +235,7 @@ namespace simpleApp`
`234`	`235`	`if (!(static_cast<header_base_type>(header) & static_cast<header_base_type>(msg_headers::sender_client)))`
`235`	`236`	`{`
`236`	`237`	`sendMsgError();`
`237`		`- return session_result {session_status::proceed_udp_wrong_header};`
	`238`	`+ return session_result {session_status::proceed_wrong_header};`
`238`	`239`	`}`
`239`	`240`
`240`	`241`	`if (len == sizeof(msg_headers))`
`@@ -259,30 +260,23 @@ namespace simpleApp`
`259`	`260`
`260`	`261`	`default:`
`261`	`262`	`sendMsgError();`
`262`		`- return session_result {session_status::proceed_udp_wrong_header};`
	`263`	`+ return session_result {session_status::proceed_wrong_header};`
`263`	`264`	`};`
`264`	`265`	`}`
`265`	`266`	`else if (header == msg_headers::client_msg)`
`266`	`267`	`{`
`267`		`- // TODO replace this with required logic`
`268`	`268`	`uint8_t buff[MESSAGE_MAX_BUFFER];`
`269`	`269`
`270`		`- const char* buff = "DELIVERED";`
`271`		`- const msg_headers buffHeader = msg_headers::server_msg;`
	`270`	`+ auto sendLen = proceedMsg(msgBuff, len, buff);`
`272`	`271`
`273`		`- this->timerReset();`
`274`		`-`
`275`		`- std::memcpy(buff, &buffHeader, sizeof(buffHeader));`
`276`		`- std::memcpy(buff + static_cast<ptrdiff_t>(sizeof(buffHeader)), buff, sizeof("DELIVERED"));`
`277`		`-`
`278`		`- if (send(this->_socket, buff, sizeof(buffHeader) + sizeof("DELIVERED"), 0) == -1)`
	`272`	`+ if (send(this->_socket, buff, sendLen, 0) == -1)`
`279`	`273`	`return session_result {session_status::proceed_send_fail, errno};`
`280`	`274`	`return session_result {session_status::proceed_msg_send};`
`281`	`275`	`}`
`282`	`276`	`else`
`283`	`277`	`{`
`284`	`278`	`sendMsgError();`
`285`		`- return session_result {session_status::proceed_udp_wrong_header};`
	`279`	`+ return session_result {session_status::proceed_wrong_header};`
`286`	`280`	`}`
`287`	`281`	`}`
`288`	`282`	`}`