WIP - Add Zephyr port for socket APIs

Signed-off-by: Jimmy Huang <[email protected]>

Author: jimmy-huang

targets/zephyr/src/jerry-port.c

@@ -16,6 +16,10 @@
 #include <stdarg.h>
 
 #include <zephyr.h>
+#ifdef JERRY_DEBUGGER
+#include <sys/fcntl.h>
+#include <net/socket.h>
+#endif
 
 #include "jerryscript-port.h"
 
@@ -82,3 +86,218 @@ jerryx_port_handler_print_char (char c) /**< the character to print */
 {
   printf ("%c", c);
 } /* jerryx_port_handler_print_char */
+
+#ifdef JERRY_DEBUGGER
+
+struct jerry_debugger_config_t {
+  int debugger_port; /**< debugger socket communication port */
+};
+
+struct jerry_debugger_conn_t {
+  int fd; /**< holds the file descriptor of the socket communication */
+};
+
+static jerry_debugger_config_t socket_config = {
+  .debugger_port = 0,
+};
+
+static jerry_debugger_conn_t socket_connection; /**< client connection */
+
+/**
+ * Provide the implementation of debugger accept api.
+ *
+ * @return the accepted incoming debugger connection
+ *
+ * Note:
+ *      This function is only available if the port implementation library is
+ *      compiled with the JERRY_DEBUGGER macro.
+ */
+static jerry_debugger_conn_t*
+jerry_debugger_socket_accept (jerry_debugger_transport_t *transport_p) /**< transport object */
+{
+  int server_socket;
+  struct sockaddr_in addr;
+  socklen_t sin_size = sizeof (struct sockaddr_in);
+
+  addr.sin_family = AF_INET;
+  addr.sin_port = htons (transport_p->config_p->debugger_port);
+  addr.sin_addr.s_addr = INADDR_ANY;
+
+  if ((server_socket = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1)
+  {
+    jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: %s\n", strerror (errno));
+    return NULL;
+  }
+
+  if (bind (server_socket, (struct sockaddr *)&addr, sizeof (struct sockaddr)) == -1)
+  {
+    close (server_socket);
+    jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: %s\n", strerror (errno));
+    return NULL;
+  }
+
+  if (listen (server_socket, 1) == -1)
+  {
+    close (server_socket);
+    jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: %s\n", strerror (errno));
+    return NULL;
+  }
+
+  int client_socket = accept (server_socket, (struct sockaddr *)&addr, &sin_size);
+  close (server_socket);
+
+  if (client_socket == -1) {
+    return NULL;
+  }
+
+  /* Set non-blocking mode. */
+  int socket_flags = fcntl (client_socket, F_GETFL, 0);
+
+  if (socket_flags < 0)
+  {
+    close (client_socket);
+    return NULL;
+  }
+
+  if (fcntl (client_socket, F_SETFL, socket_flags | O_NONBLOCK) == -1)
+  {
+    close (client_socket);
+    return NULL;
+  }
+
+  char str[NET_IPV4_ADDR_LEN];
+  net_addr_ntop(AF_INET, &addr.sin_addr, str, sizeof(str));
+  jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "Connected from: %s\n", str);
+
+  socket_connection.fd = client_socket;
+
+  return &socket_connection;
+} /* jerry_debugger_socket_accept */
+
+/**
+ * Provide the implementation of debugger send api.
+ * Send message to the client side.
+ *
+ * @return JERRY_CONN_ERROR_NONE - if the data was sent successfully to the client side
+ *         JERRY_CONN_ERROR_INVALID - if the connection is invalid
+ *         JERRY_CONN_ERROR_AGAIN - if the transfer didn't go through immediately, but can try again later
+ *         JERRY_CONN_ERROR_IO - if the data failed to send
+ * Note:
+ *      This function is only available if the port implementation library is
+ *      compiled with the JERRY_DEBUGGER macro.
+ */
+static jerry_debugger_conn_errors_t
+jerry_debugger_socket_send (jerry_debugger_conn_t *connection_p, /**< connection pointer */
+                            const void *data_p, /**< data pointer */
+                            size_t data_len, /**< data size */
+                            ssize_t *bytes_sent) /**< bytes sent */
+{
+  if (!connection_p)
+  {
+    *bytes_sent = -1;
+    return JERRY_CONN_ERROR_INVALID;
+  }
+
+  *bytes_sent = send (connection_p->fd, data_p, data_len, 0);
+
+  if (*bytes_sent < 0)
+  {
+    if (errno == EWOULDBLOCK)
+    {
+      return JERRY_CONN_ERROR_AGAIN;
+    }
+    else
+    {
+      jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: %s\n", strerror (errno));
+      return JERRY_CONN_ERROR_IO;
+    }
+  }
+
+  return JERRY_CONN_ERROR_NONE;
+} /* jerry_debugger_socket_send */
+
+/**
+ * Provide the implementation of debugger receive api.
+ * Receive message from the client side.
+ *
+ * @return JERRY_CONN_ERROR_NONE - if the data was received successfully from the client side
+ *         JERRY_CONN_ERROR_INVALID - if the connection is invalid
+ *         JERRY_CONN_ERROR_AGAIN - if there's no incoming data, you should try again later
+ *         JERRY_CONN_ERROR_IO - if the data failed to receive
+ * Note:
+ *      This function is only available if the port implementation library is
+ *      compiled with the JERRY_DEBUGGER macro.
+ */
+static jerry_debugger_conn_errors_t
+jerry_debugger_socket_receive(jerry_debugger_conn_t *connection_p, /**< connection pointer */
+                              void *data_p, /**< data pointer */
+                              size_t max_len, /**< max data size */
+                              ssize_t *bytes_received) /**< bytes received */
+{
+  if (!connection_p)
+  {
+    *bytes_received = -1;
+    return JERRY_CONN_ERROR_INVALID;
+  }
+
+  *bytes_received = recv (connection_p->fd, data_p, max_len, 0);
+
+  if (*bytes_received < 0)
+  {
+    if (errno == EWOULDBLOCK)
+    {
+      return JERRY_CONN_ERROR_AGAIN;
+    }
+    else
+    {
+      jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: %s\n", strerror (errno));
+      return JERRY_CONN_ERROR_IO;
+    }
+  }
+
+  return JERRY_CONN_ERROR_NONE;
+} /* jerry_debugger_socket_receive */
+
+/**
+ * Provide the implementation of debugger close api.
+ * Closes the debugger connection.
+ *
+ * @return JERRY_CONN_ERROR_NONE - if successful
+ *         JERRY_CONN_ERROR_INVALID - if the connection is invalid
+ * Note:
+ *      This function is only available if the port implementation library is
+ *      compiled with the JERRY_DEBUGGER macro.
+ */
+static jerry_debugger_conn_errors_t
+jerry_debugger_socket_close (jerry_debugger_conn_t *connection_p) /**< connection pointer */
+{
+  if (!connection_p)
+  {
+    return JERRY_CONN_ERROR_INVALID;
+  }
+
+  close (connection_p->fd);
+  return JERRY_CONN_ERROR_NONE;
+} /* jerry_debugger_socket_close */
+
+static jerry_debugger_transport_t socket_transport = {
+  .config_p = &socket_config,
+  .accept  = jerry_debugger_socket_accept,
+  .send = jerry_debugger_socket_send,
+  .receive = jerry_debugger_socket_receive,
+  .close = jerry_debugger_socket_close,
+};
+
+/**
+ * Create and return the socket transport on the provided port for the debugger
+ *
+ * @return the transport created
+ */
+jerry_debugger_transport_t*
+jerry_debugger_init_socket_transport(uint16_t tcp_port) /**< server port number */
+{
+  socket_transport.config_p->debugger_port = tcp_port;
+  return &socket_transport;
+}
+
+#endif /* JERRY_DEBUGGER */