Continue of client main loop implementation.

Author: drclaws

client/MainConsole.cpp

@@ -4,6 +4,7 @@
 
 #include <sys/eventfd.h>
 #include <sys/select.h>
+#include <arpa/inet.h>
 
 #include <errno.h>
 #include <unistd.h>
@@ -173,7 +174,116 @@ namespace simpleApp
 
             if (FD_ISSET(STDIN_FILENO, &fd_in))
             {
-                // TODO
+                char buffer[MESSAGE_MAX_BUFFER - sizeof(msg_headers)];
+
+                int len = 0;
+                // TODO read from stdin
+                // len = read(stdin, buffer);
+                    
+                if (len == 0)
+                {
+                    std::cout << " >> " << std::flush;
+                }
+                else if (currentState == console_state::protocol_selection)
+                {
+                    if (len != 1 || (buffer[0] != 'u' && buffer[0] != 't'))
+                    {
+                        std::cout << "Invalid input. [u]dp or [t]cp?" << std::endl << 
+                            " >> " << std::flush;
+                    }
+                    else
+                    {
+                        if (buffer[0] == 'u')
+                            currentSession = new SessionTcp();
+                        else
+                            currentSession = new SessionUdp();
+                        
+                        switchState(console_state::address_input);
+                    }
+                }
+                else if (currentState == console_state::address_input)
+                {
+                    auto address = inet_addr(buffer);
+
+                    if (address == INADDR_NONE)
+                    {
+                        std::cout << "The entered IP address is incorrect. Try again" << std::endl
+                            << " >> " << std::flush; 
+                    }
+                    else
+                    {
+                        auto result = currentSession->init(address);
+                        if (result.status == session_status::init_success)
+                        {
+                            switchState(console_state::connected);
+                        }
+                        else
+                        {
+                            switch(result.status)
+                            {
+                            case session_status::init_socket_fail:
+                                std::cout << "Socket initialization failed";
+                                break;
+                            case session_status::init_connection_fail:
+                                std::cout << "Connection failed";
+                                break;
+                            case session_status::init_udp_send_up_fail:
+                            case session_status::init_udp_recv_up_fail:
+                                std::cout << "Connection request failed";
+                                break;
+                            case session_status::recv_wrong_length:
+                            case session_status::recv_wrong_header:
+                                std::cout << "Received message corrupted";
+                                break;
+                            default:
+                                std::cout << "Unknown error";
+                                break;
+                            }
+
+                            if (result.err != 0)
+                                std::cout << " with code " << result.err << std::endl << std::flush;
+                            else
+                                std::cout << std::endl << std::flush;
+                            
+                            switchState(console_state::protocol_selection);
+                        }
+                    }
+                }
+                else if (currentState == console_state::connected)
+                {
+                    auto result = currentSession->proceed(buffer, len);
+                    if (result.status == session_status::proceed_msg)
+                    {
+                        std::cout << "Received answer: '" << result.recvMsg << "'" << std::endl <<
+                            " >> " << std::flush;
+                    }
+                    else
+                    {
+                        switch(result.status)
+                        {
+                        case session_status::proceed_msg_send_fail:
+                            std::cout << "Message sending failed";
+                            break;
+                        case session_status::proceed_msg_recv_fail:
+                            std::cout << "Message receiving failed";
+                            break;
+                        case session_status::recv_wrong_length:
+                        case session_status::recv_wrong_header:
+                            std::cout << "Message has been corrupted";
+                            break;
+                        default:
+                            std::cout << "Unknown error";
+                            break;
+                        }
+
+                        if (result.err != 0)
+                            std::cout << " with code " << result.err << std::endl << std::flush;
+                        else
+                            std::cout << std::endl << std::flush;
+                        
+                        switchState(console_state::protocol_selection);
+                    }
+                }                
             }
         }
 

client/SessionClient.cpp

@@ -89,8 +89,32 @@ namespace simpleApp
         }
         else if (sendMsg != nullptr && msgSize != 0)
         {
-            // TODO
-            return session_status();
+            if (this->sendMessage(msg_headers::client_msg, sendMsg, msgSize) == -1)
+            {
+                return session_result(session_status::proceed_msg_send_fail, errno);
+            }
+
+            uint8_t buffer[MESSAGE_MAX_BUFFER];
+            auto len = recv(this->_socket, buffer, MESSAGE_MAX_BUFFER, MSG_NOSIGNAL);
+
+            if (len == -1)
+            {
+                return session_result(session_status::proceed_msg_recv_fail);
+            }
+            else if (static_cast<size_t>(len) <= sizeof(msg_headers))
+            {
+                return session_result(session_status::recv_wrong_length);
+            }
+            
+            msg_headers header = *reinterpret_cast<msg_headers*>(buffer);
+
+            if (header != msg_headers::server_msg)
+            {
+                return session_result(session_status::recv_wrong_header);
+            }
+
+            return session_result(
+                std::string((char *)(buffer + sizeof(msg_headers)), len - sizeof(msg_headers)));
         }
         else
         {

client/SessionUdp.cpp

@@ -42,7 +42,7 @@ namespace simpleApp
 
         if (len == -1)
         {
-            auto result = session_result(session_status::init_connection_fail, errno);
+            auto result = session_result(session_status::init_udp_recv_up_fail, errno);
             this->sessionClose();
             return result;
         }

client/console_state.h

@@ -4,7 +4,6 @@ namespace simpleApp
 {
     enum class console_state
     {
-        none,
         protocol_selection,
         address_input,
         connected