Merge pull request #1 from Show-maket/vanilla-server

vanilla

src/EthernetOverride/Server.cpp

@@ -12,105 +12,124 @@ void EthernetMaketServer::resetServerHandler()
     serverHandler = [](EthernetMaketClient &sclient) {};
 }
 
-EthernetMaketClient EthernetMaketServer::available(int sock)
+// EthernetMaketClient EthernetMaketServer::available(int sock)
-{
+// {
-    accept(sock);
+//     accept(sock);
-    EthernetClient client(sock);
+//     EthernetClient client(sock);
-    if (EthernetClass::_server_port[sock] == _port &&
+//     if (EthernetClass::_server_port[sock] == _port &&
-        (client.status() == SnSR::ESTABLISHED ||
+//         (client.status() == SnSR::ESTABLISHED ||
-         client.status() == SnSR::CLOSE_WAIT))
+//          client.status() == SnSR::CLOSE_WAIT))
-    {
+//     {
-        if (client.available())
+//         if (client.available())
-        {
+//         {
-            return std::move(EthernetMaketClient(client));
+//             return std::move(EthernetMaketClient(client));
-        }
+//         }
-    }
+//     }
-    return std::move(EthernetMaketClient(MAX_SOCK_NUM));
+//     return std::move(EthernetMaketClient(MAX_SOCK_NUM));
-}
+// }
 
-void EthernetMaketServer::accept(int sock)
+// void EthernetMaketServer::accept(int sock)
-{
+// {
-    int listening = 0;
+//     int listening = 0;
-    EthernetClient client(sock);
+//     EthernetClient client(sock);
 
-    if (EthernetClass::_server_port[sock] == _port)
+//     if (EthernetClass::_server_port[sock] == _port)
-    {
+//     {
-        if (client.status() == SnSR::LISTEN)
+//         if (client.status() == SnSR::LISTEN)
-        {
+//         {
-            listening = 1;
+//             listening = 1;
-        }
+//         }
-        else if (client.status() == SnSR::CLOSE_WAIT && !client.available())
+//         else if (client.status() == SnSR::CLOSE_WAIT && !client.available())
-        {
+//         {
-            client.stop();
+//             Serial.println("HARD STOP");
-        }
+//             client.stop();
-    }
+//         }
+//     }
 
-    if (!listening)
+//     if (!listening)
-    {
+//     {
-        // begin();
+//         // begin();
-        begin(sock); // added
+//         begin(sock); // added
-    }
+//     }
-}
+// }
 
-void EthernetMaketServer::begin(int sock)
+// void EthernetMaketServer::begin(int sock)
-{
+// {
-    EthernetClient client(sock);
+//     EthernetClient client(sock);
-    if (client.status() == SnSR::CLOSED)
+//     if (client.status() == SnSR::CLOSED)
-    {
+//     {
-        socket(sock, SnMR::TCP, _port, 0);
+//         socket(sock, SnMR::TCP, _port, 0);
-        listen(sock);
+//         listen(sock);
-        EthernetClass::_server_port[sock] = _port;
+//         EthernetClass::_server_port[sock] = _port;
-        serverSocket = sock; 
+//         serverSocket = sock; 
-        return;
+//         return;
-    } 
+//     } 
-    // Serial.println(F("EthernetMaketServer::begin() FAIL"));
+//     // Serial.println(F("EthernetMaketServer::begin() FAIL"));
-}
+// }
-
-void EthernetMaketServer::begin()
-{
-    for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
-    EthernetClient client(sock);
-    if (client.status() == SnSR::CLOSED) {
-        socket(sock, SnMR::TCP, _port, 0);
-        listen(sock);
-        EthernetClass::_server_port[sock] = _port;
-        serverSocket = sock;
-        break;
-        }
-    } 
-    // Serial.println(F("EthernetMaketServer::begin() FAIL"));
-}
 
+// void EthernetMaketServer::begin()
+// {
+//     for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
+//     EthernetClient client(sock);
+//     if (client.status() == SnSR::CLOSED) {
+//         socket(sock, SnMR::TCP, _port, 0);
+//         listen(sock);
+//         EthernetClass::_server_port[sock] = _port;
+//         serverSocket = sock;
+//         break;
+//         }
+//     } 
+//     // Serial.println(F("EthernetMaketServer::begin() FAIL"));
+// }
+uint8_t buf[256];
 void EthernetMaketServer::tick()
 {
     // for (int sock = 0; sock < MAX_SOCK_NUM; sock++)
     {
-        EthernetMaketClient sclient = available(serverSocket);
+        EthernetClient sclient = available(/* serverSocket */);
-        if (sclient.connected() && sclient.available() > 0)
+        size_t dataSize;
+        if (sclient.connected() && (dataSize = sclient.available()) > 0)
         {
-            serverHandler(sclient);
+            Serial.println("Receive!");
+
+            memset(buf,0x00,sizeof(buf));
+            sclient.read(buf, sizeof(buf));
+
+            Serial.print("Received data: ");
+            for (int i = 0; i < dataSize; i++)
+            {
+                Serial.print(buf[i], HEX);
+                Serial.print(" ");
+            }
+            Serial.println("\n");
+
+            // sclient.activityUpdate();
+            //* serverHandler(sclient);
         }
 
 
 
 
-        // // Закрытие соединения по таймеру неактивности
-        // if (sclient.connected() && (millis() - lastActivityTime > timeout))
-        // {
-        //     Serial.println("Connection closed due to inactivity");
-        //     sclient.stop();
-        // }
-
         // if (!wasConnected && sclient.connected())
         // {
-        //     wasConnected[sock] = true;
+        //     wasConnected = true;
+        //     Serial.println("Client connected");
         // }
 
         // if (wasConnected && !sclient.connected())
         // {
-        //     wasConnected[sock] = false;
+        //     wasConnected = false;
         //     sclient.stop();
+        //     // begin(serverSocket);
         //     Serial.println("Client disconnected");
         // }
+        // // Закрытие соединения по таймеру неактивности
+        // if (sclient.connected() && (millis() - lastActivityTime > timeout))
+        // {
+        //     Serial.println("Connection closed due to inactivity");
+        //     sclient.close();
+        //     // begin(serverSocket);
+        // }
     }
+    // sclient.tick_();
 }

src/EthernetOverride/Server.h

@@ -8,20 +8,22 @@ class EthernetMaketClient;
 class EthernetMaketServer : public EthernetServer
 {
 private:
-    EthernetClient available();
+    // EthernetClient available();
-    void accept(int sock);
+    // void accept(int sock);
     std::function<void(EthernetMaketClient&)> serverHandler = [](EthernetMaketClient &sclient) {};
-    bool wasConnected[MAX_SOCK_NUM];
     SOCKET serverSocket = MAX_SOCK_NUM;
 
+    bool wasConnected;
+    EthernetMaketClient sclient;
+
 public:
     using EthernetServer::EthernetServer;
-    EthernetMaketClient available(int sock);
+    // EthernetMaketClient available(int sock);
 
     void setServerHandler(std::function<void(EthernetMaketClient)> handler);
     void resetServerHandler();
-    void begin() override;
+    // void begin() override;
-    void begin(int sock);
+    // void begin(int sock);
     void tick();
 };
 

src/EthernetOverride/TCP.cpp

@@ -62,6 +62,8 @@ ConnectionStatusSimple EthernetMaketClient::connectNonBlock(IPAddress ip, uint16
             _sock = i;
             Serial.print("SOCK <- "); Serial.println(_sock);
             break;
+
+            //todo if (s == SnSR::LISTEN){ выполнить приём и занять на время отправки сокет прослушивания }
         }
     }
 
@@ -110,7 +112,7 @@ void EthernetMaketClient::tick_(){
         Serial.print("tick_() sock = "); Serial.println(_sock); 
     }
 
-
+//todo [] Пересмотреть стейт машину перевести на нативные статусы
     switch (connectStatus)
     {
     case CONNECT_START:
@@ -249,7 +251,8 @@ void EthernetMaketClient::tick_(){
     }
 //********************************************************
 
-    // //? Проверка наличия доступных данных от сервера
+    // //? [*] Проверка наличия доступных данных от сервера
+    // //? проверяется во вне
     // if (available() > 0)
     // {
         
@@ -297,37 +300,6 @@ void EthernetMaketClient::dataWrite(uint8_t* data, uint16_t dataSize, bool overr
     }
 }
 
-
-// bool EthernetMaketClient::send(uint8_t* data, uint16_t dataSize, IPAddress ip, uint16_t port) {
-//     this->dataPtr = data;
-//     this->dataSize = dataSize;
-//     dstIP = ip;
-//     dstPort = port;
-
-//     switch (connectStatus) {
-//         case CONNECT_CONNECTED:
-//             if(dataWrite()){
-//                 onSendSuccess();
-//             }
-//             // Если подключено, отправляем данные
-//             return true;
-
-//         case CONNECT_STOP_WAITING:
-//         case CONNECT_STOP_START:
-//             return false; // Ожидаем завершения разрыва
-
-//         // case CONNECT_FAIL:
-//         case CONNECT_IDLE:
-//             connectNonBlock(ip, port);
-//             connectStatus = CONNECT_START; // Начинаем новое подключение
-//             return false; // Подключение инициировано
-
-//         default:
-//             return false; // Пока ждём подключения
-//     }
-//     return false;
-// }
-
 void EthernetMaketClient::setOnSendSuccess(const std::function<void()>& callback) {
     onSendSuccess = callback;
 }
@@ -337,6 +309,7 @@ void EthernetMaketClient::resetOnSendSuccess() {
 }
 
 void EthernetMaketClient::stop(){
+    // if(connectStatus!=CONNECT_STOP_WAITING)
     connectStatus = CONNECT_STOP_START;
 }
 
@@ -345,15 +318,6 @@ void EthernetMaketClient::startConnection(IPAddress ip, uint16_t port, bool nonB
         dstPort = port;
         isNonBlocking = nonBlock;
         connectStatus = CONNECT_START;
-        // if (nonBlock)
-        // {
-        //     connectNonBlock(dstIP, dstPort);
-        // }
-        // else
-        // {
-        //     (ConnectionStatusSimple)connect(dstIP, dstPort);
-        // }
-
 };
 
 void EthernetMaketClient::activityUpdate(){
@@ -380,6 +344,8 @@ EthernetMaketClient& EthernetMaketClient::operator=(const EthernetMaketClient& o
     this->dataSize = other.dataSize;
     this->onSendSuccess = other.onSendSuccess;
 
+    this->_sock = other._sock;
+    
     // Отключаем исполнение старого клиента
     const_cast<EthernetMaketClient&>(other).connectStatus = CONNECT_IDLE;
 

src/EthernetOverride/TCPSession.h

@@ -1,15 +0,0 @@
-#include "TCP.h"
-
-static EthernetMaketClient tcpSock[MAX_SOCK_NUM];
-
-using TCP_SESSION = SOCKET;
-
-TCP_SESSION newConnection(IPAddress ip, uint16_t port, bool nonBlock = true){
-    for(int i = 0; i < MAX_SOCK_NUM; i++){
-        if(tcpSock[i].status() == SnSR::CLOSED){
-            tcpSock[i].startConnection(ip, port, nonBlock);
-            return i;
-        }
-    }
-    return MAX_SOCK_NUM;
-}