scs: implement DoShellServer

libraries/libstratosphere/source/scs/scs_shell_server.cpp

@@ -17,6 +17,73 @@
 
 namespace ams::scs {
 
+    namespace {
+
+        s32 CreateSocket() {
+            while (true) {
+                /* Try to create a socket. */
+                if (const auto desc = htcs::Socket(); desc >= 0) {
+                    return desc;
+                }
+
+                /* Wait 100ms before trying again. */
+                os::SleepThread(TimeSpan::FromMilliSeconds(100));
+            }
+        }
+
+        s32 AcceptSocket(s32 listen_socket) {
+            htcs::SockAddrHtcs temp;
+            return htcs::Accept(listen_socket, std::addressof(temp));
+        }
+
+        s32 Bind(s32 socket, const htcs::HtcsPortName &port_name) {
+            /* Set up the bind address. */
+            htcs::SockAddrHtcs addr;
+            addr.family    = htcs::HTCS_AF_HTCS;
+            addr.peer_name = htcs::GetPeerNameAny();
+            std::strcpy(addr.port_name.name, port_name.name);
+
+            /* Bind. */
+            return htcs::Bind(socket, std::addressof(addr));
+        }
+
+        htcs::ssize_t Receive(s32 socket, void *buffer, size_t size) {
+            u8 *dst = static_cast<u8 *>(buffer);
+            size_t received = 0;
+
+            while (received < size) {
+                const auto ret = htcs::Recv(socket, dst + received, size - received, 0);
+                if (ret <= 0) {
+                    return ret;
+                }
+
+                received += ret;
+            }
+
+            return static_cast<htcs::ssize_t>(received);
+        }
+
+        bool ReceiveCommand(CommandHeader *header, void *buffer, size_t buffer_size, s32 socket) {
+            /* Receive the header. */
+            if (Receive(socket, header, sizeof(*header)) != sizeof(*header)) {
+                return false;
+            }
+
+            /* Check that the body will fit in the buffer. */
+            if (header->body_size >= buffer_size) {
+                return false;
+            }
+
+            /* Receive the body. */
+            if(Receive(socket, buffer, header->body_size) != static_cast<htcs::ssize_t>(header->body_size)) {
+                return false;
+            }
+
+            return true;
+        }
+
+    }
+
     void ShellServer::Initialize(const char *port_name, void *stack, size_t stack_size, CommandProcessor *command_processor) {
         /* Set our variables. */
         m_command_processor = command_processor;
@@ -34,8 +101,53 @@ namespace ams::scs {
     }
 
     void ShellServer::DoShellServer() {
-        /* TODO */
-        AMS_ABORT("ShellServer::DoShellServer");
+        /* Loop servicing the shell server. */
+        while (true) {
+            /* Create a socket to listen on. */
+            const auto listen_socket = CreateSocket();
+            ON_SCOPE_EXIT { htcs::Close(listen_socket); };
+
+            /* Bind to the listen socket. */
+            if (Bind(listen_socket, m_port_name) != 0) {
+                continue;
+            }
+
+            /* Loop processing on our bound socket. */
+            while (true) {
+                /* Listen on the socket. */
+                if (const s32 listen_result = htcs::Listen(listen_socket, 0); listen_result != 0) {
+                    /* TODO: logging. */
+                    break;
+                }
+
+                /* Accept a socket. */
+                const s32 socket = AcceptSocket(listen_socket);
+                if (socket <= 0) {
+                    /* TODO: logging. */
+                    continue;
+                }
+
+                /* Ensure that the socket is cleaned up when we're done with it. */
+                ON_SCOPE_EXIT {
+                    UnregisterSocket(socket);
+                    htcs::Close(socket);
+                };
+
+                /* Loop servicing the socket. */
+                while (true) {
+                    /* Receive a command header. */
+                    CommandHeader header;
+                    if (!ReceiveCommand(std::addressof(header), m_buffer, sizeof(m_buffer), socket)) {
+                        break;
+                    }
+
+                    /* Process the command. */
+                    if (!m_command_processor->ProcessCommand(header, m_buffer, socket)) {
+                        break;
+                    }
+                }
+            }
+        }
     }
 
 }