xbintsc 0.1.9 → 0.1.11

package/runtime/ext_node/dgram/dgram.c

@@ -0,0 +1,337 @@
+/*
+ * Node.js `dgram` for xbintsc.
+ *
+ * UDP sockets driven by the core event loop. `createSocket(...)` returns an
+ * EventEmitter with `bind`, `send`, `close` and `address`; inbound datagrams
+ * are delivered to `message` listeners together with an `rinfo` object.
+ */
+
+#include "../node_common.h"
+
+#include <errno.h>
+#include <string.h>
+
+#if defined(_WIN32)
+#include <winsock2.h>
+#include <ws2tcpip.h>
+typedef int xt_socklen_t;
+#define xt_close_socket closesocket
+#else
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+typedef socklen_t xt_socklen_t;
+#define xt_close_socket close
+#endif
+
+int xt_node_is_buffer(xt_value value);
+unsigned char *xt_node_buffer_bytes(xt_value value, size_t *outLength);
+
+static xt_value xt_dgram_socket_proto(void);
+
+static void xt_dgram_set_nonblocking(int fd) {
+#if defined(_WIN32)
+  u_long mode = 1;
+  ioctlsocket(fd, FIONBIO, &mode);
+#else
+  int flags = fcntl(fd, F_GETFL, 0);
+  if (flags >= 0) fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+#endif
+}
+
+static xt_value *xt_dgram_box(xt_value value) {
+  xt_value *handle = (xt_value *)malloc(sizeof(xt_value));
+  *handle = value;
+  return handle;
+}
+
+static int xt_dgram_fd(xt_value socket) { return (int)xt_to_number(xt_object_get_cstr(socket, "__fd")); }
+
+static unsigned char *xt_dgram_bytes(xt_value data, size_t *outLength) {
+  if (xt_node_is_buffer(data)) return xt_node_buffer_bytes(data, outLength);
+  const char *text = xt_string_data(xt_to_string(data));
+  size_t length = text ? strlen(text) : 0;
+  unsigned char *bytes = (unsigned char *)malloc(length + 1);
+  if (length > 0 && text) memcpy(bytes, text, length);
+  bytes[length] = '\0';
+  *outLength = length;
+  return bytes;
+}
+
+static void xt_dgram_read(void *userdata, int events) {
+  (void)events;
+  xt_value socket = *(xt_value *)userdata;
+  int fd = xt_dgram_fd(socket);
+  if (fd < 0) return;
+
+  unsigned char buffer[65536];
+  struct sockaddr_storage storage;
+  xt_socklen_t length = sizeof(storage);
+#if defined(_WIN32)
+  int count = recvfrom(fd, (char *)buffer, (int)sizeof(buffer), 0, (struct sockaddr *)&storage, &length);
+#else
+  ssize_t count = recvfrom(fd, buffer, sizeof(buffer), 0, (struct sockaddr *)&storage, &length);
+#endif
+  if (count < 0) return;
+
+  char host[NI_MAXHOST];
+  char service[NI_MAXSERV];
+  if (getnameinfo((struct sockaddr *)&storage, length, host, sizeof(host), service, sizeof(service),
+                  NI_NUMERICHOST | NI_NUMERICSERV) != 0)
+    return;
+
+  xt_value rinfo = xt_object_new();
+  xt_node_set(rinfo, "address", xt_string_from_cstr(host));
+  xt_node_set(rinfo, "port", xt_number((double)atoi(service)));
+  xt_node_set(rinfo, "family", xt_string_from_cstr(strchr(host, ':') ? "IPv6" : "IPv4"));
+  xt_node_set(rinfo, "size", xt_number((double)count));
+
+  const char *encoding = xt_node_encoding(xt_object_get_cstr(socket, "__encoding"));
+  xt_value chunk = xt_node_encode(buffer, (size_t)count, encoding);
+  xt_node_emit(socket, "message", 2, (xt_value[]){chunk, rinfo});
+}
+
+/* bind([port][, address][, callback]) | bind(options[, callback]) */
+static xt_value xt_dgram_bind(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  int port = 0;
+  const char *address = NULL;
+  xt_value callback = XT_UNDEFINED;
+  int index = 0;
+  if (argc > 0 && XT_IS_OBJECT(argv[0])) {
+    xt_value portValue = xt_object_get_cstr(argv[0], "port");
+    if (!xt_truthy(xt_is_nullish(portValue))) port = (int)xt_to_number(portValue);
+    xt_value addressValue = xt_object_get_cstr(argv[0], "address");
+    if (XT_IS_STRING(addressValue)) address = xt_string_data(addressValue);
+    index = 1;
+  } else if (argc > 0 && XT_IS_NUMBER(argv[0])) {
+    port = (int)xt_to_number(argv[0]);
+    index = 1;
+    if (argc > 1 && XT_IS_STRING(argv[1])) {
+      address = xt_string_data(argv[1]);
+      index = 2;
+    }
+  }
+  for (int32_t i = index; i < argc; i++) {
+    if (XT_IS_FUNCTION(argv[i])) callback = argv[i];
+  }
+
+  const char *type = xt_string_data(xt_to_string(xt_object_get_cstr(thisValue, "__type")));
+  int family = (type && strcmp(type, "udp6") == 0) ? AF_INET6 : AF_INET;
+  if (address && strchr(address, ':')) family = AF_INET6;
+
+  int fd = socket(family, SOCK_DGRAM, 0);
+  if (fd < 0) return thisValue;
+  int yes = 1;
+  setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&yes, sizeof(yes));
+
+  char service[16];
+  snprintf(service, sizeof(service), "%d", port);
+  struct addrinfo hints;
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = family;
+  hints.ai_socktype = SOCK_DGRAM;
+  hints.ai_flags = AI_PASSIVE;
+  struct addrinfo *result = NULL;
+  int bound = -1;
+  if (getaddrinfo(address, service, &hints, &result) == 0) {
+    for (struct addrinfo *info = result; info; info = info->ai_next) {
+      if (bind(fd, info->ai_addr, info->ai_addrlen) == 0) {
+        bound = 0;
+        break;
+      }
+    }
+    freeaddrinfo(result);
+  }
+  if (bound != 0) {
+    xt_close_socket(fd);
+    xt_value error = xt_string_from_cstr("EADDRINUSE");
+    xt_node_emit1(thisValue, "error", error);
+    if (XT_IS_FUNCTION(callback)) xt_call_with_this(callback, xt_undefined(), 1, &error);
+    return thisValue;
+  }
+
+  xt_dgram_set_nonblocking(fd);
+  xt_node_set(thisValue, "__fd", xt_number((double)fd));
+  xt_node_set(thisValue, "__bound", xt_bool(1));
+  xt_loop_add(fd, XT_IO_READ, xt_dgram_read, xt_dgram_box(thisValue));
+
+  xt_node_emit0(thisValue, "listening");
+  if (XT_IS_FUNCTION(callback)) xt_call_with_this(callback, xt_undefined(), 0, NULL);
+  return thisValue;
+}
+
+static int xt_dgram_resolve(const char *host, int port, struct sockaddr_storage *storage, xt_socklen_t *length) {
+  char service[16];
+  snprintf(service, sizeof(service), "%d", port);
+  struct addrinfo hints;
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = AF_UNSPEC;
+  hints.ai_socktype = SOCK_DGRAM;
+  struct addrinfo *result = NULL;
+  if (getaddrinfo(host, service, &hints, &result) != 0) return -1;
+  int status = -1;
+  if (result) {
+    memcpy(storage, result->ai_addr, result->ai_addrlen);
+    *length = (xt_socklen_t)result->ai_addrlen;
+    status = 0;
+  }
+  freeaddrinfo(result);
+  return status;
+}
+
+/* send(msg[, offset, length], port[, address][, callback]) */
+static xt_value xt_dgram_send(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  int fd = xt_dgram_fd(thisValue);
+  /* Node auto-binds an unbound socket on the first send. */
+  if (fd < 0) {
+    xt_dgram_bind(thisValue, env, 0, NULL);
+    fd = xt_dgram_fd(thisValue);
+  }
+  size_t length = 0;
+  unsigned char *bytes = xt_dgram_bytes(xt_arg(argc, argv, 0), &length);
+
+  int port = 0;
+  const char *address = "127.0.0.1";
+  xt_value callback = XT_UNDEFINED;
+  /* The final numeric argument is the destination port; any earlier numbers
+   * are the optional `offset`/`length` (currently unused, the whole message is
+   * sent). The first string is the address and the first function a callback. */
+  for (int32_t i = 1; i < argc; i++) {
+    if (XT_IS_NUMBER(argv[i])) port = (int)xt_to_number(argv[i]);
+    else if (XT_IS_STRING(argv[i]) && strcmp(address, "127.0.0.1") == 0) address = xt_string_data(argv[i]);
+    else if (XT_IS_FUNCTION(argv[i])) callback = argv[i];
+  }
+
+  xt_value error = XT_UNDEFINED;
+  if (fd < 0) {
+    error = xt_string_from_cstr("ERR_SOCKET_DGRAM_NOT_RUNNING");
+  } else {
+    struct sockaddr_storage storage;
+    xt_socklen_t storageLength = 0;
+    if (xt_dgram_resolve(address, port, &storage, &storageLength) != 0) {
+      error = xt_string_from_cstr("EAI_FAIL");
+    } else if (sendto(fd, (const char *)bytes, length, 0, (struct sockaddr *)&storage, storageLength) < 0) {
+      error = xt_string_from_cstr("EIO");
+    }
+  }
+  free(bytes);
+
+  if (!xt_truthy(xt_is_nullish(error))) {
+    xt_node_emit1(thisValue, "error", error);
+    if (XT_IS_FUNCTION(callback)) xt_call_with_this(callback, xt_undefined(), 1, &error);
+  } else if (XT_IS_FUNCTION(callback)) {
+    xt_call_with_this(callback, xt_undefined(), 0, NULL);
+  }
+  return thisValue;
+}
+
+static xt_value xt_dgram_close(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  int fd = xt_dgram_fd(thisValue);
+  if (fd >= 0) {
+    xt_loop_remove(fd);
+    xt_close_socket(fd);
+  }
+  xt_node_set(thisValue, "__fd", xt_number(-1));
+  xt_value callback = XT_IS_FUNCTION(xt_arg(argc, argv, 0)) ? xt_arg(argc, argv, 0) : XT_UNDEFINED;
+  xt_node_emit0(thisValue, "close");
+  if (XT_IS_FUNCTION(callback)) xt_call_with_this(callback, xt_undefined(), 0, NULL);
+  return thisValue;
+}
+
+static xt_value xt_dgram_address(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  int fd = xt_dgram_fd(thisValue);
+  if (fd < 0) return xt_null();
+  struct sockaddr_storage storage;
+  xt_socklen_t length = sizeof(storage);
+  if (getsockname(fd, (struct sockaddr *)&storage, &length) != 0) return xt_null();
+  char host[NI_MAXHOST];
+  char service[NI_MAXSERV];
+  if (getnameinfo((struct sockaddr *)&storage, length, host, sizeof(host), service, sizeof(service),
+                  NI_NUMERICHOST | NI_NUMERICSERV) != 0)
+    return xt_null();
+  xt_value object = xt_object_new();
+  xt_node_set(object, "address", xt_string_from_cstr(host));
+  xt_node_set(object, "port", xt_number((double)atoi(service)));
+  xt_node_set(object, "family", xt_string_from_cstr(strchr(host, ':') ? "IPv6" : "IPv4"));
+  return object;
+}
+
+static xt_value xt_dgram_set_broadcast(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  int fd = xt_dgram_fd(thisValue);
+  int value = argc > 0 ? (int)xt_to_number(argv[0]) : 1;
+  if (fd >= 0) setsockopt(fd, SOL_SOCKET, SO_BROADCAST, (const char *)&value, sizeof(value));
+  return thisValue;
+}
+
+static xt_value xt_dgram_set_ttl(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  int fd = xt_dgram_fd(thisValue);
+  int value = argc > 0 ? (int)xt_to_number(argv[0]) : 1;
+  if (fd >= 0) setsockopt(fd, IPPROTO_IP, IP_TTL, (const char *)&value, sizeof(value));
+  return thisValue;
+}
+
+static xt_value xt_dgram_noop(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return thisValue;
+}
+
+xt_value xt_node_dgram_create_socket(int32_t argc, xt_value *argv) {
+  const char *type = "udp4";
+  xt_value callback = XT_UNDEFINED;
+  if (argc > 0 && XT_IS_STRING(argv[0])) type = xt_string_data(argv[0]);
+  else if (argc > 0 && XT_IS_OBJECT(argv[0])) {
+    xt_value typeValue = xt_object_get_cstr(argv[0], "type");
+    if (XT_IS_STRING(typeValue)) type = xt_string_data(typeValue);
+  }
+  for (int32_t i = 0; i < argc; i++) {
+    if (XT_IS_FUNCTION(argv[i])) callback = argv[i];
+  }
+
+  xt_value socket = xt_object_new_with_proto(xt_dgram_socket_proto());
+  xt_node_set(socket, "__fd", xt_number(-1));
+  xt_node_set(socket, "__type", xt_string_from_cstr(type));
+  if (XT_IS_FUNCTION(callback)) xt_array_push(xt_node_listeners(socket, "message", 1), callback);
+  return socket;
+}
+
+xt_value xt_dgram_static(xt_value name, int32_t argc, xt_value *argv) {
+  const char *fn = xt_string_data(name);
+  if (!fn) return xt_undefined();
+  if (strcmp(fn, "createSocket") == 0) return xt_node_dgram_create_socket(argc, argv);
+  return xt_undefined();
+}
+
+static xt_value xt_dgram_socket_proto(void) {
+  static xt_value proto = 0;
+  if (proto) return proto;
+  proto = xt_object_new();
+  xt_node_install_emitter(proto);
+  xt_node_define_method(proto, "bind", (void *)xt_dgram_bind);
+  xt_node_define_method(proto, "send", (void *)xt_dgram_send);
+  xt_node_define_method(proto, "close", (void *)xt_dgram_close);
+  xt_node_define_method(proto, "address", (void *)xt_dgram_address);
+  xt_node_define_method(proto, "setBroadcast", (void *)xt_dgram_set_broadcast);
+  xt_node_define_method(proto, "setTTL", (void *)xt_dgram_set_ttl);
+  xt_node_define_method(proto, "setMulticastTTL", (void *)xt_dgram_set_ttl);
+  xt_node_define_method(proto, "setMulticastLoopback", (void *)xt_dgram_set_broadcast);
+  xt_node_define_method(proto, "setRecvBufferSize", (void *)xt_dgram_noop);
+  xt_node_define_method(proto, "setSendBufferSize", (void *)xt_dgram_noop);
+  xt_node_define_method(proto, "addMembership", (void *)xt_dgram_noop);
+  xt_node_define_method(proto, "dropMembership", (void *)xt_dgram_noop);
+  xt_node_define_method(proto, "ref", (void *)xt_dgram_noop);
+  xt_node_define_method(proto, "unref", (void *)xt_dgram_noop);
+  return proto;
+}

package/runtime/ext_node/fs/fs_common.h

@@ -0,0 +1,166 @@
+/*
+ * Shared helpers for the xbintsc Node `fs` runtime.
+ *
+ * The `fs` builtins live in several translation units (read_file.c,
+ * write_file.c, fs_ops.c) but agree on encoding handling and error reporting
+ * through these static inline helpers. Encoding support is deliberately
+ * buffer-free: `base64`/`hex` are encoded to strings directly, since xbintsc
+ * has no `Buffer` value type yet.
+ */
+#ifndef XT_NODE_FS_COMMON_H
+#define XT_NODE_FS_COMMON_H
+
+#include "rt.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static const char xt_fs_base64_alphabet[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/* Accepts a bare encoding string or an options object with `encoding`. */
+static inline const char *xt_fs_encoding(xt_value options) {
+  if (XT_IS_STRING(options)) return xt_string_data(options);
+  if (XT_IS_OBJECT(options)) {
+    xt_value encoding = xt_object_get_cstr(options, "encoding");
+    if (XT_IS_STRING(encoding)) return xt_string_data(encoding);
+  }
+  return NULL;
+}
+
+static inline int xt_fs_is_hex(const char *encoding) {
+  return encoding && strcmp(encoding, "hex") == 0;
+}
+
+static inline int xt_fs_is_base64(const char *encoding) {
+  return encoding && strcmp(encoding, "base64") == 0;
+}
+
+static inline xt_value xt_fs_encode_hex(const unsigned char *data, size_t length) {
+  static const char digits[] = "0123456789abcdef";
+  char *buffer = (char *)malloc(length * 2 + 1);
+  if (!buffer) return xt_undefined();
+  for (size_t i = 0; i < length; i++) {
+    buffer[i * 2] = digits[data[i] >> 4];
+    buffer[i * 2 + 1] = digits[data[i] & 0x0f];
+  }
+  xt_value result = xt_string_new(buffer, length * 2);
+  free(buffer);
+  return result;
+}
+
+static inline xt_value xt_fs_encode_base64(const unsigned char *data, size_t length) {
+  size_t outLength = ((length + 2) / 3) * 4;
+  char *buffer = (char *)malloc(outLength + 1);
+  if (!buffer) return xt_undefined();
+  size_t i = 0, j = 0;
+  while (i + 2 < length) {
+    uint32_t n = ((uint32_t)data[i] << 16) | ((uint32_t)data[i + 1] << 8) | (uint32_t)data[i + 2];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 18) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 12) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 6) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[n & 63];
+    i += 3;
+  }
+  if (length - i == 1) {
+    uint32_t n = (uint32_t)data[i] << 16;
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 18) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 12) & 63];
+    buffer[j++] = '=';
+    buffer[j++] = '=';
+  } else if (length - i == 2) {
+    uint32_t n = ((uint32_t)data[i] << 16) | ((uint32_t)data[i + 1] << 8);
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 18) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 12) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 6) & 63];
+    buffer[j++] = '=';
+  }
+  xt_value result = xt_string_new(buffer, j);
+  free(buffer);
+  return result;
+}
+
+/* Encode bytes for `readFileSync` according to `encoding` (default raw UTF-8). */
+static inline xt_value xt_fs_encode_bytes(const unsigned char *data, size_t length, const char *encoding) {
+  if (xt_fs_is_hex(encoding)) return xt_fs_encode_hex(data, length);
+  if (xt_fs_is_base64(encoding)) return xt_fs_encode_base64(data, length);
+  return xt_string_new((const char *)data, length);
+}
+
+static inline int xt_fs_base64_value(char c) {
+  if (c >= 'A' && c <= 'Z') return c - 'A';
+  if (c >= 'a' && c <= 'z') return c - 'a' + 26;
+  if (c >= '0' && c <= '9') return c - '0' + 52;
+  if (c == '+') return 62;
+  if (c == '/') return 63;
+  return -1;
+}
+
+static inline int xt_fs_hex_value(char c) {
+  if (c >= '0' && c <= '9') return c - '0';
+  if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+  if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+  return -1;
+}
+
+/*
+ * Decode text for `writeFileSync` according to `encoding`. Returns a malloc'd
+ * byte buffer (never NULL unless allocation failed) and stores its length in
+ * `*outLength`; the caller frees it.
+ */
+static inline unsigned char *xt_fs_decode_text(const char *text, size_t length, const char *encoding, size_t *outLength) {
+  unsigned char *bytes = NULL;
+  if (xt_fs_is_base64(encoding)) {
+    size_t capacity = (length / 4 + 1) * 3;
+    bytes = (unsigned char *)malloc(capacity + 1);
+    if (!bytes) return NULL;
+    size_t written = 0;
+    int accumulator = 0, bits = 0;
+    for (size_t i = 0; i < length; i++) {
+      if (text[i] == '=') break;
+      int value = xt_fs_base64_value(text[i]);
+      if (value < 0) continue;
+      accumulator = (accumulator << 6) | value;
+      bits += 6;
+      if (bits >= 8) {
+        bits -= 8;
+        bytes[written++] = (unsigned char)((accumulator >> bits) & 0xff);
+      }
+    }
+    bytes[written] = '\0';
+    *outLength = written;
+    return bytes;
+  }
+  if (xt_fs_is_hex(encoding)) {
+    bytes = (unsigned char *)malloc(length / 2 + 1);
+    if (!bytes) return NULL;
+    size_t written = 0;
+    int high = -1;
+    for (size_t i = 0; i < length; i++) {
+      int value = xt_fs_hex_value(text[i]);
+      if (value < 0) continue;
+      if (high < 0) {
+        high = value;
+      } else {
+        bytes[written++] = (unsigned char)((high << 4) | value);
+        high = -1;
+      }
+    }
+    bytes[written] = '\0';
+    *outLength = written;
+    return bytes;
+  }
+  bytes = (unsigned char *)malloc(length + 1);
+  if (!bytes) return NULL;
+  if (length > 0) memcpy(bytes, text, length);
+  bytes[length] = '\0';
+  *outLength = length;
+  return bytes;
+}
+
+static inline void xt_fs_error(const char *action, const char *path) {
+  fprintf(stderr, "xbintsc: cannot %s '%s'\n", action, path ? path : "");
+}
+
+#endif /* XT_NODE_FS_COMMON_H */