/*
    * Copyright (C) 2024 Jo-Philipp Wich <jo@mein.io>
    *
    * Permission to use, copy, modify, and/or distribute this software for any
    * purpose with or without fee is hereby granted, provided that the above
    * copyright notice and this permission notice appear in all copies.
    *
    * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   */
  
  /**
   * # Socket Module
   *
   * The `socket` module provides functions for interacting with sockets.
   *
   * Functions can be individually imported and directly accessed using the
   * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#named_import named import}
   * syntax:
   *
   *   ```javascript
   *   import { AF_INET, SOCK_STREAM, create as socket } from 'socket';
   *
   *   let sock = socket(AF_INET, SOCK_STREAM, 0);
   *   sock.connect('192.168.1.1', 80);
   *   sock.send(…);
   *   sock.recv(…);
   *   sock.close();
   *   ```
   *
   * Alternatively, the module namespace can be imported
   * using a wildcard import statement:
   *
   *   ```javascript
   *   import * as socket from 'socket';
   *
   *   let sock = socket.create(socket.AF_INET, socket.SOCK_STREAM, 0);
   *   sock.connect('192.168.1.1', 80);
   *   sock.send(…);
   *   sock.recv(…);
   *   sock.close();
   *   ```
   *
   * Additionally, the socket module namespace may also be imported by invoking
   * the `ucode` interpreter with the `-lsocket` switch.
   *
   * @module socket
   */
  
  #include <stdio.h>
  #include <errno.h>
  #include <string.h>
  #include <ctype.h>
  #include <sys/types.h>
  #include <sys/socket.h>
  #include <sys/stat.h>
  #include <sys/un.h>
  #include <netinet/in.h>
  #include <netinet/tcp.h>
  #include <netinet/udp.h>
  #include <arpa/inet.h>
  #include <unistd.h>
  #include <fcntl.h>
  #include <net/if.h>
  #include <netdb.h>
  #include <poll.h>
  #include <limits.h>
  #include <dirent.h>
  #include <assert.h>
  
  #include "ucode/module.h"
  #include "ucode/platform.h"
  
  #if defined(__linux__)
  # include <linux/if_packet.h>
  
  # ifndef SO_TIMESTAMP_OLD
  #  define SO_TIMESTAMP_OLD SO_TIMESTAMP
  # endif
  
  # ifndef SO_TIMESTAMPNS_OLD
  #  define SO_TIMESTAMPNS_OLD SO_TIMESTAMP
  # endif
  #endif
  
  #if defined(__APPLE__)
  # include <sys/ucred.h>
  
  # define SOCK_NONBLOCK (1 << 16)
  # define SOCK_CLOEXEC  (1 << 17)
  #endif
  
  #ifndef NI_IDN
  # define NI_IDN 0
 #endif
 
 #ifndef AI_IDN
 # define AI_IDN 0
 #endif
 
 #ifndef AI_CANONIDN
 # define AI_CANONIDN 0
 #endif
 
 #ifndef IPV6_FLOWINFO
 # define IPV6_FLOWINFO 11
 #endif
 
 #ifndef IPV6_FLOWLABEL_MGR
 # define IPV6_FLOWLABEL_MGR 32
 #endif
 
 #ifndef IPV6_FLOWINFO_SEND
 # define IPV6_FLOWINFO_SEND 33
 #endif
 
 #define ok_return(expr) do { set_error(0, NULL); return (expr); } while(0)
 #define err_return(err, ...) do { set_error(err, __VA_ARGS__); return NULL; } while(0)
 
 static struct {
         int code;
         char *msg;
 } last_error;
 
 __attribute__((format(printf, 2, 3))) static void
 set_error(int errcode, const char *fmt, ...)
 {
         va_list ap;
 
         free(last_error.msg);
 
         last_error.code = errcode;
         last_error.msg = NULL;
 
         if (fmt) {
                 va_start(ap, fmt);
                 xvasprintf(&last_error.msg, fmt, ap);
                 va_end(ap);
         }
 }
 
 static char *
 arg_type_(uc_type_t type)
 {
         switch (type) {
         case UC_INTEGER:  return "an integer value";
         case UC_BOOLEAN:  return "a boolean value";
         case UC_STRING:   return "a string value";
         case UC_DOUBLE:   return "a double value";
         case UC_ARRAY:    return "an array";
         case UC_OBJECT:   return "an object";
         case UC_REGEXP:   return "a regular expression";
         case UC_CLOSURE:  return "a function";
         case UC_RESOURCE: return "a resource value";
         default:          return "the expected type";
         }
 }
 
 static bool
 args_get_(uc_vm_t *vm, size_t nargs, int *fdptr, ...)
 {
         const char *name, *rtype = NULL;
         uc_value_t **ptr, *arg;
         uc_type_t type, t;
         size_t index = 0;
         int *sockfd;
         va_list ap;
         bool opt;
 
         if (fdptr) {
                 sockfd = uc_fn_this("socket");
 
                 if (!sockfd || *sockfd == -1)
                         err_return(EBADF, "Invalid socket context");
 
                 *fdptr = *sockfd;
         }
 
         va_start(ap, fdptr);
 
         while (true) {
                 name = va_arg(ap, const char *);
 
                 if (!name)
                         break;
 
                 arg = uc_fn_arg(index++);
 
                 type = va_arg(ap, uc_type_t);
                 opt = va_arg(ap, int);
                 ptr = va_arg(ap, uc_value_t **);
 
                 if (type == UC_RESOURCE) {
                         rtype = name;
                         name = strrchr(rtype, '.');
                         name = name ? name + 1 : rtype;
 
                         if (arg && !ucv_resource_dataptr(arg, rtype))
                                 err_return(EINVAL,
                                         "Argument %s is not a %s resource", name, rtype);
                 }
 
                 if (!opt && !arg)
                         err_return(EINVAL,
                                 "Argument %s is required", name);
 
                 t = ucv_type(arg);
 
                 if (t == UC_CFUNCTION)
                         t = UC_CLOSURE;
 
                 if (arg && type != UC_NULL && t != type)
                         err_return(EINVAL,
                                 "Argument %s is not %s", name, arg_type_(type));
 
                 *ptr = arg;
         }
 
         va_end(ap);
 
         ok_return(true);
 }
 
 #define args_get(vm, nargs, fdptr, ...) do { \
         if (!args_get_(vm, nargs, fdptr, ##__VA_ARGS__, NULL)) \
                 return NULL; \
 } while(0)
 
 static void
 strbuf_free(uc_stringbuf_t *sb)
 {
         printbuf_free(sb);
 }
 
 static bool
 strbuf_grow(uc_stringbuf_t *sb, size_t size)
 {
         if (size > 0) {
                 if (printbuf_memset(sb, sizeof(uc_string_t) + size - 1, '\0', 1))
                         err_return(ENOMEM, "Out of memory");
         }
 
         return true;
 }
 
 static char *
 strbuf_data(uc_stringbuf_t *sb)
 {
         return sb->buf + sizeof(uc_string_t);
 }
 
 static size_t
 strbuf_size(uc_stringbuf_t *sb)
 {
         return (size_t)sb->bpos - sizeof(uc_string_t);
 }
 
 static uc_value_t *
 strbuf_finish(uc_stringbuf_t **sb, size_t final_size)
 {
         size_t buffer_size;
         uc_string_t *us;
 
         if (!sb || !*sb)
                 return NULL;
 
         buffer_size = strbuf_size(*sb);
         us = (uc_string_t *)(*sb)->buf;
 
         if (final_size > buffer_size)
                 final_size = buffer_size;
 
         free(*sb);
         *sb = NULL;
 
         us = xrealloc(us, sizeof(uc_string_t) + final_size + 1);
         us->length = final_size;
         us->str[us->length] = 0;
 
         return &us->header;
 }
 
 static uc_stringbuf_t *
 strbuf_alloc(size_t size)
 {
         uc_stringbuf_t *sb = ucv_stringbuf_new();
 
         if (!strbuf_grow(sb, size)) {
                 printbuf_free(sb);
 
                 return NULL;
         }
 
         return sb;
 }
 
 #if defined(__linux__)
 static uc_value_t *
 hwaddr_to_uv(uint8_t *addr, size_t alen)
 {
         char buf[sizeof("FF:FF:FF:FF:FF:FF:FF:FF")], *p = buf;
         const char *hex = "0123456789ABCDEF";
 
         for (size_t i = 0; i < alen && i < 8; i++) {
                 if (i) *p++ = ':';
                 *p++ = hex[addr[i] / 16];
                 *p++ = hex[addr[i] % 16];
         }
 
         return ucv_string_new(buf);
 }
 
 static bool
 uv_to_hwaddr(uc_value_t *addr, uint8_t *out, size_t *outlen)
 {
         const char *p;
         size_t len;
 
         memset(out, 0, 8);
         *outlen = 0;
 
         if (ucv_type(addr) != UC_STRING)
                 goto err;
 
         len = ucv_string_length(addr);
         p = ucv_string_get(addr);
 
         while (len > 0 && isxdigit(*p) && *outlen < 8) {
                 uint8_t n = (*p > '9') ? 10 + (*p|32) - 'a' : *p - '';
                 p++, len--;
 
                 if (len > 0 && isxdigit(*p)) {
                         n = n * 16 + ((*p > '9') ? 10 + (*p|32) - 'a' : *p - '');
                         p++, len--;
                 }
 
                 if (len > 0 && (*p == ':' || *p == '-' || *p == '.'))
                         p++, len--;
 
                 out[(*outlen)++] = n;
         }
 
         if (len == 0 || *p == 0)
                 return true;
 
 err:
         err_return(EINVAL, "Invalid hardware address");
 }
 #endif
 
 static bool
 sockaddr_to_uv(struct sockaddr_storage *ss, uc_value_t *addrobj)
 {
         char *ifname, addrstr[INET6_ADDRSTRLEN];
         struct sockaddr_in6 *s6;
         struct sockaddr_in *s4;
         struct sockaddr_un *su;
 #if defined(__linux__)
         struct sockaddr_ll *sl;
 #endif
 
         ucv_object_add(addrobj, "family", ucv_uint64_new(ss->ss_family));
 
         switch (ss->ss_family) {
         case AF_INET6:
                 s6 = (struct sockaddr_in6 *)ss;
 
                 inet_ntop(AF_INET6, &s6->sin6_addr, addrstr, sizeof(addrstr));
                 ucv_object_add(addrobj, "address",
                         ucv_string_new(addrstr));
 
                 ucv_object_add(addrobj, "port",
                         ucv_uint64_new(ntohs(s6->sin6_port)));
 
                 ucv_object_add(addrobj, "flowinfo",
                         ucv_uint64_new(ntohl(s6->sin6_flowinfo)));
 
                 if (s6->sin6_scope_id) {
                         ifname = if_indextoname(s6->sin6_scope_id, addrstr);
 
                         if (ifname)
                                 ucv_object_add(addrobj, "interface",
                                         ucv_string_new(ifname));
                         else
                                 ucv_object_add(addrobj, "interface",
                                         ucv_uint64_new(s6->sin6_scope_id));
                 }
 
                 return true;
 
         case AF_INET:
                 s4 = (struct sockaddr_in *)ss;
 
                 inet_ntop(AF_INET, &s4->sin_addr, addrstr, sizeof(addrstr));
                 ucv_object_add(addrobj, "address",
                         ucv_string_new(addrstr));
 
                 ucv_object_add(addrobj, "port",
                         ucv_uint64_new(ntohs(s4->sin_port)));
 
                 return true;
 
         case AF_UNIX:
                 su = (struct sockaddr_un *)ss;
 
                 ucv_object_add(addrobj, "path",
                         ucv_string_new(su->sun_path));
 
                 return true;
 
 #if defined(__linux__)
         case AF_PACKET:
                 sl = (struct sockaddr_ll *)ss;
 
                 ucv_object_add(addrobj, "protocol",
                         ucv_uint64_new(ntohs(sl->sll_protocol)));
 
                 ifname = (sl->sll_ifindex > 0)
                         ? if_indextoname(sl->sll_ifindex, addrstr) : NULL;
 
                 if (ifname)
                         ucv_object_add(addrobj, "interface",
                                 ucv_string_new(ifname));
                 else if (sl->sll_ifindex != 0)
                         ucv_object_add(addrobj, "interface",
                                 ucv_int64_new(sl->sll_ifindex));
 
                 ucv_object_add(addrobj, "hardware_type",
                         ucv_uint64_new(sl->sll_hatype));
 
                 ucv_object_add(addrobj, "packet_type",
                         ucv_uint64_new(sl->sll_pkttype));
 
                 ucv_object_add(addrobj, "address",
                         hwaddr_to_uv(sl->sll_addr, sl->sll_halen));
 
                 return true;
 #endif
         }
 
         return false;
 }
 
 static int64_t
 parse_integer(char *s, size_t len)
 {
         union { int8_t i8; int16_t i16; int32_t i32; int64_t i64; } v;
 
         memcpy(&v, s, len < sizeof(v) ? len : sizeof(v));
 
         switch (len) {
         case 1:  return v.i8;
         case 2:  return v.i16;
         case 4:  return v.i32;
         case 8:  return v.i64;
         default: return 0;
         }
 }
 
 static uint64_t
 parse_unsigned(char *s, size_t len)
 {
         union { uint8_t u8; uint16_t u16; uint32_t u32; uint64_t u64; } v;
 
         memcpy(&v, s, len < sizeof(v) ? len : sizeof(v));
 
         switch (len) {
         case 1:  return v.u8;
         case 2:  return v.u16;
         case 4:  return v.u32;
         case 8:  return v.u64;
         default: return 0;
         }
 }
 
 static bool
 parse_addr(char *addr, struct sockaddr_storage *ss)
 {
         bool v6 = (ss->ss_family == 0 || ss->ss_family == AF_INET6);
         bool v4 = (ss->ss_family == 0 || ss->ss_family == AF_INET);
         struct sockaddr_in6 *s6 = (struct sockaddr_in6 *)ss;
         struct sockaddr_in *s4 = (struct sockaddr_in *)ss;
         unsigned long n;
         char *scope, *e;
 
         if (v6 && (scope = strchr(addr, '%')) != NULL) {
                 *scope++ = 0;
                 n = strtoul(scope, &e, 10);
 
                 if (e == scope || *e != 0) {
                         n = if_nametoindex(scope);
 
                         if (n == 0)
                                 err_return(errno, "Unable to resolve interface %s", scope);
                 }
 
                 if (inet_pton(AF_INET6, addr, &s6->sin6_addr) != 1)
                         err_return(errno, "Invalid IPv6 address");
 
                 s6->sin6_family = AF_INET6;
                 s6->sin6_scope_id = n;
 
                 return true;
         }
         else if (v6 && inet_pton(AF_INET6, addr, &s6->sin6_addr) == 1) {
                 s6->sin6_family = AF_INET6;
 
                 return true;
         }
         else if (v4 && inet_pton(AF_INET, addr, &s4->sin_addr) == 1) {
                 s4->sin_family = AF_INET;
 
                 return true;
         }
 
         err_return(EINVAL, "Unable to parse IP address");
 }
 
 static bool
 uv_to_sockaddr(uc_value_t *addr, struct sockaddr_storage *ss, socklen_t *slen)
 {
         char *s, *p, addrstr[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255%2147483648")];
         struct sockaddr_in6 *s6 = (struct sockaddr_in6 *)ss;
         struct sockaddr_in *s4 = (struct sockaddr_in *)ss;
         struct sockaddr_un *su = (struct sockaddr_un *)ss;
 #if defined(__linux__)
         struct sockaddr_ll *sl = (struct sockaddr_ll *)ss;
 #endif
         uc_value_t *item;
         unsigned long n;
         size_t len;
 
         memset(ss, 0, sizeof(*ss));
 
         if (ucv_type(addr) == UC_STRING) {
                 s = ucv_string_get(addr);
                 len = ucv_string_length(addr);
 
                 if (memchr(s, '/', len) != NULL) {
                         if (len >= sizeof(su->sun_path))
                                 len = sizeof(su->sun_path) - 1;
 
                         memcpy(su->sun_path, s, len);
                         su->sun_path[len++] = 0;
                         su->sun_family = AF_UNIX;
                         *slen = sizeof(*su);
 
                         ok_return(true);
                 }
 
                 if (len == 0)
                         err_return(EINVAL, "Invalid IP address");
 
                 if (*s == '[') {
                         p = memchr(++s, ']', --len);
 
                         if (!p || (size_t)(p - s) >= sizeof(addrstr))
                                 err_return(EINVAL, "Invalid IPv6 address");
 
                         memcpy(addrstr, s, p - s);
                         addrstr[(p - s) + 1] = 0;
 
                         ss->ss_family = AF_INET6;
                         len -= ((p - s) + 1);
                         s = p + 1;
                 }
                 else if ((p = memchr(s, ':', len)) != NULL &&
                          memchr(p + 1, ':', len - ((p - s) + 1)) == NULL) {
                         if ((size_t)(p - s) >= sizeof(addrstr))
                                 err_return(EINVAL, "Invalid IP address");
 
                         memcpy(addrstr, s, p - s);
                         addrstr[p - s + 1] = 0;
 
                         ss->ss_family = AF_INET;
                         len -= (p - s);
                         s = p;
                 }
                 else {
                         if (len >= sizeof(addrstr))
                                 err_return(EINVAL, "Invalid IP address");
 
                         memcpy(addrstr, s, len);
                         addrstr[len] = 0;
 
                         ss->ss_family = 0;
                         len = 0;
                         s = NULL;
                 }
 
                 if (!parse_addr(addrstr, ss))
                         return NULL;
 
                 if (s && *s == ':') {
                         if (len <= 1)
                                 err_return(EINVAL, "Invalid port number");
 
                         for (s++, len--, n = 0; len > 0; len--, s++) {
                                 if (*s < '' || *s > '9')
                                         err_return(EINVAL, "Invalid port number");
 
                                 n = n * 10 + (*s - '');
                         }
 
                         if (n > 65535)
                                 err_return(EINVAL, "Invalid port number");
 
                         s6->sin6_port = htons(n);
                 }
 
                 *slen = (ss->ss_family == AF_INET6) ? sizeof(*s6) : sizeof(*s4);
 
                 ok_return(true);
         }
         else if (ucv_type(addr) == UC_ARRAY) {
                 if (ucv_array_length(addr) == 16) {
                         uint8_t *u8 = (uint8_t *)&s6->sin6_addr;
 
                         for (size_t i = 0; i < 16; i++) {
                                 item = ucv_array_get(addr, i);
                                 n = ucv_uint64_get(item);
 
                                 if (ucv_type(item) != UC_INTEGER || errno != 0 || n > 255)
                                         err_return(EINVAL, "Invalid IP address array");
 
                                 u8[i] = n;
                         }
 
                         s6->sin6_family = AF_INET6;
                         *slen = sizeof(*s6);
 
                         ok_return(true);
                 }
                 else if (ucv_array_length(addr) == 4) {
                         s4->sin_addr.s_addr = 0;
 
                         for (size_t i = 0; i < 4; i++) {
                                 item = ucv_array_get(addr, i);
                                 n = ucv_uint64_get(item);
 
                                 if (ucv_type(item) != UC_INTEGER || errno != 0 || n > 255)
                                         err_return(EINVAL, "Invalid IP address array");
 
                                 s4->sin_addr.s_addr = s4->sin_addr.s_addr * 256 + n;
                         }
 
                         s4->sin_addr.s_addr = htonl(s4->sin_addr.s_addr);
                         s4->sin_family = AF_INET;
                         *slen = sizeof(*s4);
 
                         ok_return(true);
                 }
 
                 err_return(EINVAL, "Invalid IP address array");
         }
         else if (ucv_type(addr) == UC_OBJECT) {
                 n = ucv_to_unsigned(ucv_object_get(addr, "family", NULL));
 
                 if (n == 0) {
                         if (ucv_type(ucv_object_get(addr, "path", NULL)) == UC_STRING) {
                                 n = AF_UNIX;
                         }
                         else {
                                 item = ucv_object_get(addr, "address", NULL);
                                 len = ucv_string_length(item);
                                 s = ucv_string_get(item);
                                 n = (s && memchr(s, ':', len) != NULL) ? AF_INET6 : AF_INET;
                         }
 
                         if (n == 0)
                                 err_return(EINVAL, "Invalid address object");
                 }
 
                 switch (n) {
                 case AF_INET6:
                         item = ucv_object_get(addr, "flowinfo", NULL);
                         s6->sin6_flowinfo = htonl(ucv_to_unsigned(item));
 
                         item = ucv_object_get(addr, "interface", NULL);
 
                         if (ucv_type(item) == UC_STRING) {
                                 s6->sin6_scope_id = if_nametoindex(ucv_string_get(item));
 
                                 if (s6->sin6_scope_id == 0)
                                         err_return(errno, "Unable to resolve interface %s",
                                                 ucv_string_get(item));
                         }
                         else if (item != NULL) {
                                 s6->sin6_scope_id = ucv_to_unsigned(item);
 
                                 if (errno != 0)
                                         err_return(errno, "Invalid scope ID");
                         }
 
                         /* fall through */
 
                 case AF_INET:
                         ss->ss_family = n;
                         *slen = (n == AF_INET6) ? sizeof(*s6) : sizeof(*s4);
 
                         item = ucv_object_get(addr, "port", NULL);
                         n = ucv_to_unsigned(item);
 
                         if (errno != 0 || n > 65535)
                                 err_return(EINVAL, "Invalid port number");
 
                         s6->sin6_port = htons(n);
 
                         item = ucv_object_get(addr, "address", NULL);
                         len = ucv_string_length(item);
                         s = ucv_string_get(item);
 
                         if (len >= sizeof(addrstr))
                                 err_return(EINVAL, "Invalid IP address");
 
                         if (len > 0) {
                                 memcpy(addrstr, s, len);
                                 addrstr[len] = 0;
 
                                 if (!parse_addr(addrstr, ss))
                                         return NULL;
                         }
 
                         ok_return(true);
 
                 case AF_UNIX:
                         item = ucv_object_get(addr, "path", NULL);
                         len = ucv_string_length(item);
 
                         if (len == 0 || len >= sizeof(su->sun_path))
                                 err_return(EINVAL, "Invalid path value");
 
                         memcpy(su->sun_path, ucv_string_get(item), len);
                         su->sun_path[len++] = 0;
                         su->sun_family = AF_UNIX;
                         *slen = sizeof(*su);
 
                         ok_return(true);
 
 #if defined(__linux__)
                 case AF_PACKET:
                         item = ucv_object_get(addr, "protocol", NULL);
 
                         if (item) {
                                 n = ucv_to_unsigned(item);
 
                                 if (errno != 0 || n > 65535)
                                         err_return(EINVAL, "Invalid protocol number");
 
                                 sl->sll_protocol = htons(n);
                         }
 
                         item = ucv_object_get(addr, "address", NULL);
 
                         if (uv_to_hwaddr(item, sl->sll_addr, &len))
                                 sl->sll_halen = len;
                         else
                                 return false;
 
                         item = ucv_object_get(addr, "interface", NULL);
 
                         if (ucv_type(item) == UC_STRING) {
                                 sl->sll_ifindex = if_nametoindex(ucv_string_get(item));
 
                                 if (sl->sll_ifindex == 0)
                                         err_return(errno, "Unable to resolve interface %s",
                                                 ucv_string_get(item));
                         }
                         else if (item != NULL) {
                                 sl->sll_ifindex = ucv_to_integer(item);
 
                                 if (errno)
                                         err_return(errno, "Unable to convert interface to integer");
                         }
 
                         item = ucv_object_get(addr, "hardware_type", NULL);
 
                         if (item) {
                                 n = ucv_to_unsigned(item);
 
                                 if (errno != 0 || n > 65535)
                                         err_return(EINVAL, "Invalid hardware type");
 
                                 sl->sll_hatype = n;
                         }
 
                         item = ucv_object_get(addr, "packet_type", NULL);
 
                         if (item) {
                                 n = ucv_to_unsigned(item);
 
                                 if (errno != 0 || n > 255)
                                         err_return(EINVAL, "Invalid packet type");
 
                                 sl->sll_pkttype = n;
                         }
 
                         sl->sll_family = AF_PACKET;
                         *slen = sizeof(*sl);
 
                         ok_return(true);
 #endif
                 }
         }
 
         err_return(EINVAL, "Invalid address value");
 }
 
 static bool
 uv_to_fileno(uc_vm_t *vm, uc_value_t *val, int *fileno)
 {
         uc_value_t *fn;
         int *fdptr;
 
         fdptr = (int *)ucv_resource_dataptr(val, "socket");
 
         if (fdptr) {
                 if (*fdptr < 0)
                         err_return(EBADF, "Socket is closed");
 
                 *fileno = *fdptr;
 
                 return true;
         }
 
         fn = ucv_property_get(val, "fileno");
 
         if (ucv_is_callable(fn)) {
                 uc_vm_stack_push(vm, ucv_get(val));
                 uc_vm_stack_push(vm, ucv_get(fn));
 
                 if (uc_vm_call(vm, true, 0) != EXCEPTION_NONE)
                         return false;
 
                 val = uc_vm_stack_pop(vm);
         }
         else {
                 ucv_get(val);
         }
 
         *fileno = ucv_int64_get(val);
 
         ucv_put(val);
 
         if (errno != 0 || *fileno < 0)
                 err_return(EBADF, "Invalid file descriptor number");
 
         return true;
 }
 
 static uc_value_t *
 uv_to_pollfd(uc_vm_t *vm, uc_value_t *val, struct pollfd *pfd)
 {
         uc_value_t *rv;
         int64_t flags;
 
         if (ucv_type(val) == UC_ARRAY) {
                 if (!uv_to_fileno(vm, ucv_array_get(val, 0), &pfd->fd))
                         return NULL;
 
                 flags = ucv_to_integer(ucv_array_get(val, 1));
 
                 if (errno != 0 || flags < -32768 || flags > 32767)
                         err_return(ERANGE, "Flags value out of range");
 
                 pfd->events = flags;
                 pfd->revents = 0;
 
                 return ucv_get(val);
         }
 
         if (!uv_to_fileno(vm, val, &pfd->fd))
                 return NULL;
 
         pfd->events = POLLIN | POLLERR | POLLHUP;
         pfd->revents = 0;
 
         rv = ucv_array_new_length(vm, 2);
 
         ucv_array_set(rv, 0, ucv_get(val));
         ucv_array_set(rv, 1, ucv_uint64_new(pfd->events));
 
         return rv;
 }
 
 static uc_value_t *
 ucv_socket_new(uc_vm_t *vm, int fd)
 {
         return ucv_resource_new(
                 ucv_resource_type_lookup(vm, "socket"),
                 (void *)(intptr_t)fd
         );
 }
 
 static bool
 xclose(int *fdptr)
 {
         bool rv = true;
 
         if (fdptr) {
                 if (*fdptr >= 0)
                         rv = (close(*fdptr) == 0);
 
                 *fdptr = -1;
         }
 
         return rv;
 }
 
 
 typedef struct {
     const char *name;
     enum { DT_SIGNED, DT_UNSIGNED, DT_IPV4ADDR, DT_IPV6ADDR, DT_CALLBACK } type;
         union {
         size_t offset;
                 bool (*to_c)(void *, uc_value_t *);
         } u1;
         union {
                 size_t size;
                 uc_value_t *(*to_uv)(void *);
         } u2;
 } member_t;
 
 typedef struct {
         size_t size;
         member_t *members;
 } struct_t;
 
 typedef struct {
         int level;
         int option;
         struct_t *ctype;
 } sockopt_t;
 
 typedef struct {
         int level;
         int type;
         struct_t *ctype;
 } cmsgtype_t;
 
 #define STRUCT_MEMBER_NP(struct_name, member_name, data_type)   \
         { #member_name, data_type,                                                                      \
           { .offset = offsetof(struct struct_name, member_name) },      \
           { .size = sizeof(((struct struct_name *)NULL)->member_name) } }
 
 #define STRUCT_MEMBER_CB(member_name, to_c_fn, to_uv_fn)                \
         { #member_name, DT_CALLBACK, { .to_c = to_c_fn }, { .to_uv = to_uv_fn } }
 
 #define STRUCT_MEMBER(struct_name, member_prefix, member_name, data_type)                       \
         { #member_name, data_type,                                                                                                              \
           { .offset = offsetof(struct struct_name, member_prefix##_##member_name) },    \
           { .size = sizeof(((struct struct_name *)NULL)->member_prefix##_##member_name) } }
 
 static struct_t st_timeval = {
         .size = sizeof(struct timeval),
         .members = (member_t []){
                 STRUCT_MEMBER(timeval, tv, sec, DT_SIGNED),
                 STRUCT_MEMBER(timeval, tv, usec, DT_SIGNED),
                 { 0 }
         }
 };
 
 #if defined(__linux__)
 static struct_t st_ucred = {
         .size = sizeof(struct ucred),
         .members = (member_t []){
                 STRUCT_MEMBER_NP(ucred, pid, DT_SIGNED),
                 STRUCT_MEMBER_NP(ucred, uid, DT_SIGNED),
                 STRUCT_MEMBER_NP(ucred, gid, DT_SIGNED),
                 { 0 }
         }
 };
 #endif
 
 static struct_t st_linger = {
         .size = sizeof(struct linger),
         .members = (member_t []){
                 STRUCT_MEMBER(linger, l, onoff, DT_SIGNED),
                 STRUCT_MEMBER(linger, l, linger, DT_SIGNED),
                 { 0 }
         }
 };
 
 static struct_t st_ip_mreqn = {
         .size = sizeof(struct ip_mreqn),
         .members = (member_t []){
                 STRUCT_MEMBER(ip_mreqn, imr, multiaddr, DT_IPV4ADDR),
                 STRUCT_MEMBER(ip_mreqn, imr, address, DT_IPV4ADDR),
                 STRUCT_MEMBER(ip_mreqn, imr, ifindex, DT_SIGNED),
                 { 0 }
         }
 };
 
 static struct_t st_ip_mreq_source = {
         .size = sizeof(struct ip_mreq_source),
         .members = (member_t []){
                 STRUCT_MEMBER(ip_mreq_source, imr, multiaddr, DT_IPV4ADDR),
                 STRUCT_MEMBER(ip_mreq_source, imr, interface, DT_IPV4ADDR),
                 STRUCT_MEMBER(ip_mreq_source, imr, sourceaddr, DT_IPV4ADDR),
                 { 0 }
         }
 };
 
 /* This structure is declared in kernel, but not libc headers, so redeclare it
    locally */
 struct in6_flowlabel_req_local {
         struct in6_addr flr_dst;
         uint32_t flr_label;
         uint8_t flr_action;
         uint8_t flr_share;
         uint16_t flr_flags;
         uint16_t flr_expires;
         uint16_t flr_linger;
 };
 
 static struct_t st_in6_flowlabel_req = {
         .size = sizeof(struct in6_flowlabel_req_local),
         .members = (member_t []){
                 STRUCT_MEMBER(in6_flowlabel_req_local, flr, dst, DT_IPV6ADDR),
                 STRUCT_MEMBER(in6_flowlabel_req_local, flr, label, DT_UNSIGNED),
                 STRUCT_MEMBER(in6_flowlabel_req_local, flr, action, DT_UNSIGNED),
                 STRUCT_MEMBER(in6_flowlabel_req_local, flr, share, DT_UNSIGNED),
                 STRUCT_MEMBER(in6_flowlabel_req_local, flr, flags, DT_UNSIGNED),
                 STRUCT_MEMBER(in6_flowlabel_req_local, flr, expires, DT_UNSIGNED),
                 STRUCT_MEMBER(in6_flowlabel_req_local, flr, linger, DT_UNSIGNED),
                 { 0 }
         }
 };
 
 #if defined(__linux__)
 static uc_value_t *
 in6_ifindex_to_uv(void *st)
 {
         char ifname[IF_NAMESIZE] = { 0 };
         struct ipv6_mreq *mr = st;
 
         if (mr->ipv6mr_interface > 0 && if_indextoname(mr->ipv6mr_interface, ifname))
                 return ucv_string_new(ifname);
 
         return ucv_int64_new(mr->ipv6mr_interface);
 }
 
 static bool
 in6_ifindex_to_c(void *st, uc_value_t *uv)
 {
         struct ipv6_mreq *mr = st;
 
         if (ucv_type(uv) == UC_STRING) {
                 mr->ipv6mr_interface = if_nametoindex(ucv_string_get(uv));
 
                 if (mr->ipv6mr_interface == 0)
                         err_return(errno, "Unable to resolve interface %s",
                                 ucv_string_get(uv));
         }
         else {
                 mr->ipv6mr_interface = ucv_to_integer(uv);
 
                 if (errno)
                         err_return(errno, "Unable to convert interface to integer");
         }
 
         return true;
 }
 
 static struct_t st_ipv6_mreq = {
         .size = sizeof(struct ipv6_mreq),
         .members = (member_t []){
                 STRUCT_MEMBER(ipv6_mreq, ipv6mr, multiaddr, DT_IPV6ADDR),
                 STRUCT_MEMBER_CB(interface, in6_ifindex_to_c, in6_ifindex_to_uv),
                 { 0 }
         }
 };
 
 /* NB: this is the same layout as struct ipv6_mreq, so we reuse the callbacks */
 static struct_t st_in6_pktinfo = {
         .size = sizeof(struct in6_pktinfo),
         .members = (member_t []){
                 STRUCT_MEMBER(in6_pktinfo, ipi6, addr, DT_IPV6ADDR),
                 STRUCT_MEMBER_CB(interface, in6_ifindex_to_c, in6_ifindex_to_uv),
                 { 0 }
         }
 };
 
 struct ipv6_recv_error_local {
         struct {
                 uint32_t ee_errno;
                 uint8_t ee_origin;
                 uint8_t ee_type;
                 uint8_t ee_code;
                 uint8_t ee_pad;
                 uint32_t ee_info;
                 union {
                         uint32_t ee_data;
                         struct {
                                 uint16_t ee_len;
                                 uint8_t ee_flags;
                                 uint8_t ee_reserved;
                         } ee_rfc4884;
                 } u;
         } ee;
         struct sockaddr_in6 offender;
 };
 
 static uc_value_t *
 offender_to_uv(void *st)
 {
         struct ipv6_recv_error_local *e = st;
         uc_value_t *addr = ucv_object_new(NULL);
 
         if (sockaddr_to_uv((struct sockaddr_storage *)&e->offender, addr))
                 return addr;
 
         ucv_put(addr);
 
         return NULL;
 }
 
 static struct_t st_ip_recv_error = {
         .size = sizeof(struct ipv6_recv_error_local),
         .members = (member_t []){
                 STRUCT_MEMBER(ipv6_recv_error_local, ee.ee, errno, DT_UNSIGNED),
                 STRUCT_MEMBER(ipv6_recv_error_local, ee.ee, origin, DT_UNSIGNED),
                 STRUCT_MEMBER(ipv6_recv_error_local, ee.ee, type, DT_UNSIGNED),
                 STRUCT_MEMBER(ipv6_recv_error_local, ee.ee, code, DT_UNSIGNED),
                 STRUCT_MEMBER(ipv6_recv_error_local, ee.ee, info, DT_UNSIGNED),
                 STRUCT_MEMBER(ipv6_recv_error_local, ee.u.ee, data, DT_UNSIGNED),
                 STRUCT_MEMBER(ipv6_recv_error_local, ee.u.ee_rfc4884.ee, len, DT_UNSIGNED),
                 STRUCT_MEMBER(ipv6_recv_error_local, ee.u.ee_rfc4884.ee, flags, DT_UNSIGNED),
                 STRUCT_MEMBER_CB(offender, NULL, offender_to_uv),
                 { 0 }
         }
 };
 
 static uc_value_t *
 ip6m_addr_to_uv(void *st)
 {
         struct ip6_mtuinfo *mi = st;
         uc_value_t *addr = ucv_object_new(NULL);
 
         if (sockaddr_to_uv((struct sockaddr_storage *)&mi->ip6m_addr, addr))
                 return addr;
 
         ucv_put(addr);
 
         return NULL;
 }
 
 static struct_t st_ip6_mtuinfo = {
         .size = sizeof(struct ip6_mtuinfo),
         .members = (member_t []){
                 STRUCT_MEMBER_CB(addr, NULL, ip6m_addr_to_uv),
                 STRUCT_MEMBER(ip6_mtuinfo, ip6m, mtu, DT_UNSIGNED),
                 { 0 }
         }
 };
 
 static struct_t st_ip_msfilter = {
         .size = sizeof(struct ip_msfilter),
         .members = (member_t []){
                 STRUCT_MEMBER(ip_msfilter, imsf, multiaddr, DT_IPV4ADDR),
                 STRUCT_MEMBER(ip_msfilter, imsf, interface, DT_IPV4ADDR),
                 STRUCT_MEMBER(ip_msfilter, imsf, fmode, DT_SIGNED),
                 STRUCT_MEMBER(ip_msfilter, imsf, numsrc, DT_SIGNED),
                 STRUCT_MEMBER(ip_msfilter, imsf, slist, DT_SIGNED),
                 { 0 }
         }
 };
 
 static uc_value_t *
 snd_wscale_to_uv(void *st)
 {
         return ucv_uint64_new(((struct tcp_info *)st)->tcpi_snd_wscale);
 }
 
 static uc_value_t *
 rcv_wscale_to_uv(void *st)
 {
         return ucv_uint64_new(((struct tcp_info *)st)->tcpi_rcv_wscale);
 }
 
 static bool
 snd_wscale_to_c(void *st, uc_value_t *uv)
 {
         ((struct tcp_info *)st)->tcpi_snd_wscale = ucv_to_unsigned(uv);
 
         if (errno)
                 err_return(errno, "Unable to convert field snd_wscale to unsigned");
 
         return true;
 }
 
 static bool
 rcv_wscale_to_c(void *st, uc_value_t *uv)
 {
         ((struct tcp_info *)st)->tcpi_rcv_wscale = ucv_to_unsigned(uv);
 
         if (errno)
                 err_return(errno, "Unable to convert field rcv_wscale to unsigned");
 
         return true;
 }
 
 static struct_t st_tcp_info = {
         .size = sizeof(struct tcp_info),
         .members = (member_t []){
                 STRUCT_MEMBER(tcp_info, tcpi, state, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, ca_state, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, retransmits, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, probes, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, backoff, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, options, DT_UNSIGNED),
                 STRUCT_MEMBER_CB(snd_wscale, snd_wscale_to_c, snd_wscale_to_uv),
                 STRUCT_MEMBER_CB(rcv_wscale, rcv_wscale_to_c, rcv_wscale_to_uv),
                 STRUCT_MEMBER(tcp_info, tcpi, rto, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, ato, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, snd_mss, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, rcv_mss, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, unacked, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, sacked, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, lost, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, retrans, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, fackets, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, last_data_sent, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, last_ack_sent, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, last_data_recv, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, last_ack_recv, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, pmtu, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, rcv_ssthresh, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, rtt, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, rttvar, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, snd_ssthresh, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, snd_cwnd, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, advmss, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, reordering, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, rcv_rtt, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, rcv_space, DT_UNSIGNED),
                 STRUCT_MEMBER(tcp_info, tcpi, total_retrans, DT_UNSIGNED),
                 { 0 }
         }
 };
 #endif
 
 static uc_value_t *
 ai_addr_to_uv(void *st)
 {
         uc_value_t *rv = ucv_object_new(NULL);
         struct sockaddr_storage ss = { 0 };
         struct addrinfo *ai = st;
 
         memcpy(&ss, ai->ai_addr, ai->ai_addrlen);
 
         if (!sockaddr_to_uv(&ss, rv)) {
                 ucv_put(rv);
                 return NULL;
         }
 
         return rv;
 }
 
 static uc_value_t *
 ai_canonname_to_uv(void *st)
 {
         struct addrinfo *ai = st;
         return ai->ai_canonname ? ucv_string_new(ai->ai_canonname) : NULL;
 }
 
 /**
  * Represents a network address information object returned by
  * {@link module:socket#addrinfo|`addrinfo()`}.
  *
  * @typedef {Object} module:socket.AddressInfo
  *
  * @property {module:socket.socket.SocketAddress} addr - A socket address structure.
  * @property {string} [canonname=null] - The canonical hostname associated with the address.
  * @property {number} family - The address family (e.g., `2` for `AF_INET`, `10` for `AF_INET6`).
  * @property {number} flags - Additional flags indicating properties of the address.
  * @property {number} protocol - The protocol number.
  * @property {number} socktype - The socket type (e.g., `1` for `SOCK_STREAM`, `2` for `SOCK_DGRAM`).
  */
 static struct_t st_addrinfo = {
         .size = sizeof(struct addrinfo),
         .members = (member_t []){
                 STRUCT_MEMBER(addrinfo, ai, flags, DT_SIGNED),
                 STRUCT_MEMBER(addrinfo, ai, family, DT_SIGNED),
                 STRUCT_MEMBER(addrinfo, ai, socktype, DT_SIGNED),
                 STRUCT_MEMBER(addrinfo, ai, protocol, DT_SIGNED),
                 STRUCT_MEMBER_CB(addr, NULL, ai_addr_to_uv),
                 STRUCT_MEMBER_CB(canonname, NULL, ai_canonname_to_uv),
                 { 0 }
         }
 };
 
 #if defined(__linux__)
 static uc_value_t *
 mr_ifindex_to_uv(void *st)
 {
         char ifname[IF_NAMESIZE] = { 0 };
         struct packet_mreq *mr = st;
 
         if (mr->mr_ifindex > 0 && if_indextoname(mr->mr_ifindex, ifname))
                 return ucv_string_new(ifname);
 
         return ucv_int64_new(mr->mr_ifindex);
 }
 
 static bool
 mr_ifindex_to_c(void *st, uc_value_t *uv)
 {
         struct packet_mreq *mr = st;
 
         if (ucv_type(uv) == UC_STRING) {
                 mr->mr_ifindex = if_nametoindex(ucv_string_get(uv));
 
                 if (mr->mr_ifindex == 0)
                         err_return(errno, "Unable to resolve interface %s",
                                 ucv_string_get(uv));
         }
         else {
                 mr->mr_ifindex = ucv_to_integer(uv);
 
                 if (errno)
                         err_return(errno, "Unable to convert interface to integer");
         }
 
         return true;
 }
 
 static uc_value_t *
 mr_address_to_uv(void *st)
 {
         struct packet_mreq *mr = st;
 
         return hwaddr_to_uv(mr->mr_address, mr->mr_alen);
 }
 
 static bool
 mr_address_to_c(void *st, uc_value_t *uv)
 {
         struct packet_mreq *mr = st;
         size_t len;
 
         if (!uv_to_hwaddr(uv, mr->mr_address, &len))
                 return false;
 
         mr->mr_alen = len;
 
         return true;
 }
 
 static struct_t st_packet_mreq = {
         .size = sizeof(struct packet_mreq),
         .members = (member_t []){
                 STRUCT_MEMBER_CB(interface, mr_ifindex_to_c, mr_ifindex_to_uv),
                 STRUCT_MEMBER(packet_mreq, mr, type, DT_UNSIGNED),
                 STRUCT_MEMBER_CB(address, mr_address_to_c, mr_address_to_uv),
                 { 0 }
         }
 };
 
 static struct_t st_tpacket_req = {
         .size = sizeof(struct tpacket_req),
         .members = (member_t []){
                 STRUCT_MEMBER(tpacket_req, tp, block_size, DT_UNSIGNED),
                 STRUCT_MEMBER(tpacket_req, tp, block_nr, DT_UNSIGNED),
                 STRUCT_MEMBER(tpacket_req, tp, frame_size, DT_UNSIGNED),
                 STRUCT_MEMBER(tpacket_req, tp, frame_nr, DT_UNSIGNED),
                 { 0 }
         }
 };
 
 static struct_t st_tpacket_stats = {
         .size = sizeof(struct tpacket_stats),
         .members = (member_t []){
                 STRUCT_MEMBER(tpacket_stats, tp, packets, DT_UNSIGNED),
                 STRUCT_MEMBER(tpacket_stats, tp, drops, DT_UNSIGNED),
                 { 0 }
         }
 };
 
 static struct_t st_tpacket_auxdata = {
         .size = sizeof(struct tpacket_auxdata),
         .members = (member_t []){
                 STRUCT_MEMBER(tpacket_auxdata, tp, status, DT_UNSIGNED),
                 STRUCT_MEMBER(tpacket_auxdata, tp, len, DT_UNSIGNED),
                 STRUCT_MEMBER(tpacket_auxdata, tp, snaplen, DT_UNSIGNED),
                 STRUCT_MEMBER(tpacket_auxdata, tp, mac, DT_UNSIGNED),
                 STRUCT_MEMBER(tpacket_auxdata, tp, net, DT_UNSIGNED),
                 STRUCT_MEMBER(tpacket_auxdata, tp, vlan_tci, DT_UNSIGNED),
                 STRUCT_MEMBER(tpacket_auxdata, tp, vlan_tpid, DT_UNSIGNED),
                 { 0 }
         }
 };
 
 static struct_t st_fanout_args = {
         .size = sizeof(struct fanout_args),
         .members = (member_t []){
                 STRUCT_MEMBER_NP(fanout_args, id, DT_UNSIGNED),
                 STRUCT_MEMBER_NP(fanout_args, type_flags, DT_UNSIGNED),
                 STRUCT_MEMBER_NP(fanout_args, max_num_members, DT_UNSIGNED),
                 { 0 }
         }
 };
 
 struct timeval_old_local {
         long tv_sec;
 #if defined(__sparc__) && defined(__arch64__)
         int tv_usec;
 #else
         long tv_usec;
 #endif
 };
 
 static struct_t st_timeval_old = {
         .size = sizeof(struct timeval_old_local),
         .members = (member_t []){
                 STRUCT_MEMBER(timeval_old_local, tv, sec, DT_SIGNED),
                 STRUCT_MEMBER(timeval_old_local, tv, usec, DT_SIGNED),
                 { 0 }
         }
 };
 
 # ifdef SO_TIMESTAMP_NEW
 struct timeval_new_local { int64_t tv_sec; int64_t tv_usec; };
 static struct_t st_timeval_new = {
         .size = sizeof(struct timeval_old_local),
         .members = (member_t []){
                 STRUCT_MEMBER(timeval_new_local, tv, sec, DT_SIGNED),
                 STRUCT_MEMBER(timeval_new_local, tv, usec, DT_SIGNED),
                 { 0 }
         }
 };
 # endif
 
 struct timespec_old_local { long tv_sec; long tv_nsec; };
 static struct_t st_timespec_old = {
         .size = sizeof(struct timespec_old_local),
         .members = (member_t []){
                 STRUCT_MEMBER(timespec_old_local, tv, sec, DT_SIGNED),
                 STRUCT_MEMBER(timespec_old_local, tv, nsec, DT_SIGNED),
                 { 0 }
         }
 };
 
 # ifdef SO_TIMESTAMPNS_NEW
 struct timespec_new_local { long long tv_sec; long long tv_nsec; };
 static struct_t st_timespec_new = {
         .size = sizeof(struct timespec_new_local),
         .members = (member_t []){
                 STRUCT_MEMBER(timespec_new_local, tv, sec, DT_SIGNED),
                 STRUCT_MEMBER(timespec_new_local, tv, nsec, DT_SIGNED),
                 { 0 }
         }
 };
 # endif
 #endif
 
 #define SV_VOID         (struct_t *)0
 #define SV_INT          (struct_t *)1
 #define SV_INT_RO       (struct_t *)2
 #define SV_BOOL         (struct_t *)3
 #define SV_STRING       (struct_t *)4
 #define SV_IFNAME       (struct_t *)5
 
 #define CV_INT          (struct_t *)0
 #define CV_UINT         (struct_t *)1
 #define CV_BE32         (struct_t *)2
 #define CV_STRING       (struct_t *)3
 #define CV_SOCKADDR     (struct_t *)4
 #define CV_FDS          (struct_t *)5
 
 static sockopt_t sockopts[] = {
     { SOL_SOCKET, SO_ACCEPTCONN, SV_BOOL },
     { SOL_SOCKET, SO_BROADCAST, SV_BOOL },
     { SOL_SOCKET, SO_DEBUG, SV_BOOL },
     { SOL_SOCKET, SO_ERROR, SV_INT_RO },
     { SOL_SOCKET, SO_DONTROUTE, SV_BOOL },
     { SOL_SOCKET, SO_KEEPALIVE, SV_BOOL },
     { SOL_SOCKET, SO_LINGER, &st_linger },
     { SOL_SOCKET, SO_OOBINLINE, SV_BOOL },
     { SOL_SOCKET, SO_RCVBUF, SV_INT },
     { SOL_SOCKET, SO_RCVLOWAT, SV_INT },
     { SOL_SOCKET, SO_RCVTIMEO, &st_timeval },
     { SOL_SOCKET, SO_REUSEADDR, SV_BOOL },
     { SOL_SOCKET, SO_REUSEPORT, SV_BOOL },
     { SOL_SOCKET, SO_SNDBUF, SV_INT },
     { SOL_SOCKET, SO_SNDLOWAT, SV_INT },
     { SOL_SOCKET, SO_SNDTIMEO, &st_timeval },
     { SOL_SOCKET, SO_TIMESTAMP, SV_BOOL },
     { SOL_SOCKET, SO_TYPE, SV_INT },
 #if defined(__linux__)
     { SOL_SOCKET, SO_ATTACH_FILTER, SV_STRING },
     { SOL_SOCKET, SO_ATTACH_BPF, SV_INT },
     { SOL_SOCKET, SO_ATTACH_REUSEPORT_CBPF, SV_STRING },
     { SOL_SOCKET, SO_ATTACH_REUSEPORT_EBPF, SV_INT },
     { SOL_SOCKET, SO_BINDTODEVICE, SV_STRING },
     { SOL_SOCKET, SO_DETACH_FILTER, SV_VOID },
     { SOL_SOCKET, SO_DETACH_BPF, SV_VOID },
     { SOL_SOCKET, SO_DOMAIN, SV_INT_RO },
     { SOL_SOCKET, SO_INCOMING_CPU, SV_INT },
     { SOL_SOCKET, SO_INCOMING_NAPI_ID, SV_INT_RO },
     { SOL_SOCKET, SO_LOCK_FILTER, SV_INT },
     { SOL_SOCKET, SO_MARK, SV_INT },
     { SOL_SOCKET, SO_PASSCRED, SV_BOOL },
     { SOL_SOCKET, SO_PASSSEC, SV_BOOL },
     { SOL_SOCKET, SO_PEEK_OFF, SV_INT },
     { SOL_SOCKET, SO_PEERCRED, &st_ucred },
     { SOL_SOCKET, SO_PEERSEC, SV_STRING },
     { SOL_SOCKET, SO_PRIORITY, SV_INT },
     { SOL_SOCKET, SO_PROTOCOL, SV_INT },
     { SOL_SOCKET, SO_RCVBUFFORCE, SV_INT },
     { SOL_SOCKET, SO_RXQ_OVFL, SV_BOOL },
     { SOL_SOCKET, SO_SNDBUFFORCE, SV_INT },
     { SOL_SOCKET, SO_TIMESTAMPNS, SV_BOOL },
     { SOL_SOCKET, SO_BUSY_POLL, SV_INT },
 #endif
 
     { IPPROTO_IP, IP_ADD_MEMBERSHIP, &st_ip_mreqn },
     { IPPROTO_IP, IP_ADD_SOURCE_MEMBERSHIP, &st_ip_mreq_source },
     { IPPROTO_IP, IP_BLOCK_SOURCE, &st_ip_mreq_source },
     { IPPROTO_IP, IP_DROP_MEMBERSHIP, &st_ip_mreqn },
     { IPPROTO_IP, IP_DROP_SOURCE_MEMBERSHIP, &st_ip_mreq_source },
     { IPPROTO_IP, IP_HDRINCL, SV_BOOL },
     { IPPROTO_IP, IP_MULTICAST_IF, &st_ip_mreqn },
     { IPPROTO_IP, IP_MULTICAST_LOOP, SV_BOOL },
     { IPPROTO_IP, IP_MULTICAST_TTL, SV_INT },
     { IPPROTO_IP, IP_OPTIONS, SV_STRING },
     { IPPROTO_IP, IP_PKTINFO, SV_BOOL },
     { IPPROTO_IP, IP_RECVOPTS, SV_BOOL },
     { IPPROTO_IP, IP_RECVTOS, SV_BOOL },
     { IPPROTO_IP, IP_RECVTTL, SV_BOOL },
     { IPPROTO_IP, IP_RETOPTS, SV_BOOL },
     { IPPROTO_IP, IP_TOS, SV_INT },
     { IPPROTO_IP, IP_TTL, SV_INT },
     { IPPROTO_IP, IP_UNBLOCK_SOURCE, &st_ip_mreq_source },
 #if defined(__linux__)
     { IPPROTO_IP, IP_MSFILTER, &st_ip_msfilter },
     { IPPROTO_IP, IP_BIND_ADDRESS_NO_PORT, SV_BOOL },
     { IPPROTO_IP, IP_FREEBIND, SV_BOOL },
     { IPPROTO_IP, IP_MTU, SV_INT },
     { IPPROTO_IP, IP_MTU_DISCOVER, SV_INT },
     { IPPROTO_IP, IP_MULTICAST_ALL, SV_BOOL },
     { IPPROTO_IP, IP_NODEFRAG, SV_BOOL },
     { IPPROTO_IP, IP_PASSSEC, SV_BOOL },
     { IPPROTO_IP, IP_RECVERR, SV_BOOL },
     { IPPROTO_IP, IP_RECVORIGDSTADDR, SV_BOOL },
     { IPPROTO_IP, IP_ROUTER_ALERT, SV_BOOL },
     { IPPROTO_IP, IP_TRANSPARENT, SV_BOOL },
 #endif
 
         { IPPROTO_IPV6, IPV6_FLOWINFO_SEND, SV_BOOL },
         { IPPROTO_IPV6, IPV6_FLOWINFO, SV_BOOL },
         { IPPROTO_IPV6, IPV6_FLOWLABEL_MGR, &st_in6_flowlabel_req },
         { IPPROTO_IPV6, IPV6_MULTICAST_HOPS, SV_INT },
         { IPPROTO_IPV6, IPV6_MULTICAST_IF, SV_IFNAME },
         { IPPROTO_IPV6, IPV6_MULTICAST_LOOP, SV_BOOL },
         { IPPROTO_IPV6, IPV6_RECVTCLASS, SV_BOOL },
         { IPPROTO_IPV6, IPV6_TCLASS, SV_INT },
         { IPPROTO_IPV6, IPV6_UNICAST_HOPS, SV_INT },
         { IPPROTO_IPV6, IPV6_V6ONLY, SV_BOOL },
 #if defined(__linux__)
         { IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &st_ipv6_mreq },
         { IPPROTO_IPV6, IPV6_ADDR_PREFERENCES, SV_INT },
         { IPPROTO_IPV6, IPV6_ADDRFORM, SV_INT },
         { IPPROTO_IPV6, IPV6_AUTHHDR, SV_BOOL },
         { IPPROTO_IPV6, IPV6_AUTOFLOWLABEL, SV_BOOL },
         { IPPROTO_IPV6, IPV6_DONTFRAG, SV_BOOL },
         { IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, &st_ipv6_mreq },
         { IPPROTO_IPV6, IPV6_DSTOPTS, SV_STRING },
         { IPPROTO_IPV6, IPV6_FREEBIND, SV_BOOL },
         { IPPROTO_IPV6, IPV6_HOPLIMIT, SV_BOOL },
         { IPPROTO_IPV6, IPV6_HOPOPTS, SV_STRING },
         { IPPROTO_IPV6, IPV6_JOIN_ANYCAST, &st_ipv6_mreq },
         { IPPROTO_IPV6, IPV6_LEAVE_ANYCAST, &st_ipv6_mreq },
         { IPPROTO_IPV6, IPV6_MINHOPCOUNT, SV_INT },
         { IPPROTO_IPV6, IPV6_MTU_DISCOVER, SV_INT },
         { IPPROTO_IPV6, IPV6_MTU, SV_INT },
         { IPPROTO_IPV6, IPV6_MULTICAST_ALL, SV_BOOL },
         { IPPROTO_IPV6, IPV6_PKTINFO, &st_in6_pktinfo },
         { IPPROTO_IPV6, IPV6_RECVDSTOPTS, SV_BOOL },
         { IPPROTO_IPV6, IPV6_RECVERR, SV_BOOL },
         { IPPROTO_IPV6, IPV6_RECVFRAGSIZE, SV_BOOL },
         { IPPROTO_IPV6, IPV6_RECVHOPLIMIT, SV_BOOL },
         { IPPROTO_IPV6, IPV6_RECVHOPOPTS, SV_BOOL },
         { IPPROTO_IPV6, IPV6_RECVORIGDSTADDR, SV_BOOL },
         { IPPROTO_IPV6, IPV6_RECVPATHMTU, SV_BOOL },
         { IPPROTO_IPV6, IPV6_RECVPKTINFO, SV_BOOL },
         { IPPROTO_IPV6, IPV6_RECVRTHDR, SV_BOOL },
         { IPPROTO_IPV6, IPV6_ROUTER_ALERT_ISOLATE, SV_BOOL },
         { IPPROTO_IPV6, IPV6_ROUTER_ALERT, SV_BOOL },
         { IPPROTO_IPV6, IPV6_RTHDR, SV_STRING },
         { IPPROTO_IPV6, IPV6_RTHDRDSTOPTS, SV_STRING },
         { IPPROTO_IPV6, IPV6_TRANSPARENT, SV_BOOL },
         { IPPROTO_IPV6, IPV6_UNICAST_IF, SV_IFNAME },
 #endif
 
     { IPPROTO_TCP, TCP_KEEPCNT, SV_INT },
     { IPPROTO_TCP, TCP_KEEPINTVL, SV_INT },
     { IPPROTO_TCP, TCP_MAXSEG, SV_INT },
     { IPPROTO_TCP, TCP_NODELAY, SV_BOOL },
     { IPPROTO_TCP, TCP_FASTOPEN, SV_INT },
 #if defined(__linux__)
     { IPPROTO_TCP, TCP_CONGESTION, SV_STRING },
     { IPPROTO_TCP, TCP_CORK, SV_BOOL },
     { IPPROTO_TCP, TCP_DEFER_ACCEPT, SV_INT },
         { IPPROTO_TCP, TCP_INFO, &st_tcp_info },
     { IPPROTO_TCP, TCP_KEEPIDLE, SV_INT },
     { IPPROTO_TCP, TCP_LINGER2, SV_INT },
     { IPPROTO_TCP, TCP_QUICKACK, SV_BOOL },
     { IPPROTO_TCP, TCP_SYNCNT, SV_INT },
     { IPPROTO_TCP, TCP_USER_TIMEOUT, SV_INT },
     { IPPROTO_TCP, TCP_WINDOW_CLAMP, SV_INT },
     { IPPROTO_TCP, TCP_FASTOPEN_CONNECT, SV_INT },
 #endif
 
 #if defined(__linux__)
     { IPPROTO_UDP, UDP_CORK, SV_BOOL },
 #endif
 
 #if defined(__linux__)
         { SOL_PACKET, PACKET_ADD_MEMBERSHIP, &st_packet_mreq },
         { SOL_PACKET, PACKET_DROP_MEMBERSHIP, &st_packet_mreq },
         { SOL_PACKET, PACKET_AUXDATA, SV_BOOL },
         { SOL_PACKET, PACKET_FANOUT, &st_fanout_args },
         { SOL_PACKET, PACKET_LOSS, SV_BOOL },
         { SOL_PACKET, PACKET_RESERVE, SV_INT },
         { SOL_PACKET, PACKET_RX_RING, &st_tpacket_req },
         { SOL_PACKET, PACKET_STATISTICS, &st_tpacket_stats },
         { SOL_PACKET, PACKET_TIMESTAMP, SV_INT },
         { SOL_PACKET, PACKET_TX_RING, &st_tpacket_req },
         { SOL_PACKET, PACKET_VERSION, SV_INT },
         { SOL_PACKET, PACKET_QDISC_BYPASS, SV_BOOL },
 #endif
 };
 
 static cmsgtype_t cmsgtypes[] = {
 #if defined(__linux__)
         { SOL_PACKET, PACKET_AUXDATA, &st_tpacket_auxdata },
 
         { SOL_SOCKET, SO_TIMESTAMP_OLD, &st_timeval_old },
 # ifdef SO_TIMESTAMP_NEW
         { SOL_SOCKET, SO_TIMESTAMP_NEW, &st_timeval_new },
 # endif
         { SOL_SOCKET, SO_TIMESTAMPNS_OLD, &st_timespec_old },
 # ifdef SO_TIMESTAMPNS_NEW
         { SOL_SOCKET, SO_TIMESTAMPNS_NEW, &st_timespec_new },
 # endif
 
         { SOL_SOCKET, SCM_CREDENTIALS, &st_ucred },
         { SOL_SOCKET, SCM_RIGHTS, CV_FDS },
 #endif
 
         { IPPROTO_IP, IP_RECVOPTS, SV_STRING },
         { IPPROTO_IP, IP_RETOPTS, SV_STRING },
         { IPPROTO_IP, IP_TOS, CV_INT },
         { IPPROTO_IP, IP_TTL, CV_INT },
 #if defined(__linux__)
         { IPPROTO_IP, IP_CHECKSUM, CV_UINT },
         { IPPROTO_IP, IP_ORIGDSTADDR, CV_SOCKADDR },
         { IPPROTO_IP, IP_RECVERR, &st_ip_recv_error },
         { IPPROTO_IP, IP_RECVFRAGSIZE, CV_INT },
 #endif
 
         { IPPROTO_IPV6, IPV6_TCLASS, CV_INT },
         { IPPROTO_IPV6, IPV6_FLOWINFO, CV_BE32 },
 #if defined(__linux__)
         { IPPROTO_IPV6, IPV6_DSTOPTS, CV_STRING },
         { IPPROTO_IPV6, IPV6_HOPLIMIT, CV_INT },
         { IPPROTO_IPV6, IPV6_HOPOPTS, CV_STRING },
         { IPPROTO_IPV6, IPV6_ORIGDSTADDR, CV_SOCKADDR },
         { IPPROTO_IPV6, IPV6_PATHMTU, &st_ip6_mtuinfo },
         { IPPROTO_IPV6, IPV6_PKTINFO, &st_in6_pktinfo },
         { IPPROTO_IPV6, IPV6_RECVERR, &st_ip_recv_error },
         { IPPROTO_IPV6, IPV6_RECVFRAGSIZE, CV_INT },
         { IPPROTO_IPV6, IPV6_RTHDR, CV_STRING },
 
         { IPPROTO_TCP, TCP_CM_INQ, CV_INT },
         { IPPROTO_UDP, UDP_GRO, CV_INT },
 #endif
 };
 
 
 static char *
 uv_to_struct(uc_value_t *uv, struct_t *spec)
 {
         uc_value_t *fv;
         const char *s;
         uint64_t u64;
         int64_t s64;
         member_t *m;
         bool found;
         char *st;
 
         union {
                 int8_t s8;
                 int16_t s16;
                 int32_t s32;
                 int64_t s64;
                 uint8_t u8;
                 uint16_t u16;
                 uint32_t u32;
                 uint64_t u64;
         } v;
 
         st = xalloc(spec->size);
 
         for (size_t i = 0; spec->members[i].name; i++) {
                 m = &spec->members[i];
                 fv = ucv_object_get(uv, m->name, &found);
 
                 if (!found || !fv)
                         continue;
 
                 switch (spec->members[i].type) {
                 case DT_UNSIGNED:
                         u64 = ucv_to_unsigned(fv);
 
                         if (errno) {
                                 free(st);
                                 err_return(errno,
                                         "Unable to convert field %s to unsigned",
                                         m->name);
                         }
 
                         switch (m->u2.size) {
                         case 1:  v.u8 =  (uint8_t)u64; break;
                         case 2: v.u16 = (uint16_t)u64; break;
                         case 4: v.u32 = (uint32_t)u64; break;
                         case 8: v.u64 = (uint64_t)u64; break;
                         }
 
                         memcpy(st + m->u1.offset, &v, m->u2.size);
                         break;
 
                 case DT_SIGNED:
                         s64 = ucv_to_integer(fv);
 
                         if (errno) {
                                 free(st);
                                 err_return(errno,
                                         "Unable to convert field %s to integer", m->name);
                         }
 
                         switch (m->u2.size) {
                         case 1:  v.s8 =  (int8_t)s64; break;
                         case 2: v.s16 = (int16_t)s64; break;
                         case 4: v.s32 = (int32_t)s64; break;
                         case 8: v.s64 = (int64_t)s64; break;
                         }
 
                         memcpy(st + m->u1.offset, &v, m->u2.size);
                         break;
 
                 case DT_IPV4ADDR:
                         s = ucv_string_get(fv);
 
                         if (!s || inet_pton(AF_INET, s, st + m->u1.offset) != 1) {
                                 free(st);
                                 err_return(EINVAL,
                                         "Unable to convert field %s to IP address", m->name);
                         }
 
                         break;
 
                 case DT_IPV6ADDR:
                         s = ucv_string_get(fv);
 
                         if (!s || inet_pton(AF_INET6, s, st + m->u1.offset) != 1) {
                                 free(st);
                                 err_return(EINVAL,
                                         "Unable to convert field %s to IPv6 address", m->name);
                         }
 
                         break;
 
                 case DT_CALLBACK:
                         if (m->u1.to_c && !m->u1.to_c(st, fv)) {
                                 free(st);
                                 return NULL;
                         }
 
                         break;
                 }
         }
 
         return st;
 }
 
 static uc_value_t *
 struct_to_uv(char *st, struct_t *spec)
 {
         char s[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")];
         uc_value_t *uv, *fv;
         member_t *m;
 
         uv = ucv_object_new(NULL);
 
         for (size_t i = 0; spec->members[i].name; i++) {
                 m = &spec->members[i];
                 fv = NULL;
 
                 switch (spec->members[i].type) {
                 case DT_UNSIGNED:
                         switch (spec->members[i].u2.size) {
                         case 1:
                                 fv = ucv_uint64_new(*(uint8_t *)(st + m->u1.offset));
                                 break;
 
                         case 2:
                                 fv = ucv_uint64_new(*(uint16_t *)(st + m->u1.offset));
                                 break;
 
                         case 4:
                                 fv = ucv_uint64_new(*(uint32_t *)(st + m->u1.offset));
                                 break;
 
                         case 8:
                                 fv = ucv_uint64_new(*(uint64_t *)(st + m->u1.offset));
                                 break;
                         }
 
                         break;
 
                 case DT_SIGNED:
                         switch (spec->members[i].u2.size) {
                         case 1:
                                 fv = ucv_int64_new(*(int8_t *)(st + m->u1.offset));
                                 break;
 
                         case 2:
                                 fv = ucv_int64_new(*(int16_t *)(st + m->u1.offset));
                                 break;
 
                         case 4:
                                 fv = ucv_int64_new(*(int32_t *)(st + m->u1.offset));
                                 break;
 
                         case 8:
                                 fv = ucv_int64_new(*(int64_t *)(st + m->u1.offset));
                                 break;
                         }
 
                         break;
 
                 case DT_IPV4ADDR:
                         if (inet_ntop(AF_INET, st + m->u1.offset, s, sizeof(s)))
                                 fv = ucv_string_new(s);
 
                         break;
 
                 case DT_IPV6ADDR:
                         if (inet_ntop(AF_INET6, st + m->u1.offset, s, sizeof(s)))
                                 fv = ucv_string_new(s);
 
                         break;
 
                 case DT_CALLBACK:
                         fv = m->u2.to_uv ? m->u2.to_uv(st) : NULL;
                         break;
                 }
 
                 ucv_object_add(uv, m->name, fv);
         }
 
         return uv;
 }
 
 /**
  * Sets options on the socket.
  *
  * Sets the specified option on the socket to the given value.
  *
  * Returns `true` if the option was successfully set.
  *
  * Returns `null` if an error occurred.
  *
  * @function module:socket.socket#setopt
  *
  * @param {number} level
  * The protocol level at which the option resides. This can be a level such as
  * `SOL_SOCKET` for the socket API level or a specific protocol level defined
  * by the system.
  *
  * @param {number} option
  * The socket option to set. This can be an integer representing the option,
  * such as `SO_REUSEADDR`, or a constant defined by the system.
  *
  * @param {*} value
  * The value to set the option to. The type of this argument depends on the
  * specific option being set. It can be an integer, a boolean, a string, or a
  * dictionary representing the value to set. If a dictionary is provided, it is
  * internally translated to the corresponding C struct type required by the
  * option.
  *
  * @returns {?boolean}
  */
 static uc_value_t *
 uc_socket_inst_setopt(uc_vm_t *vm, size_t nargs)
 {
         int sockfd, solvl, soopt, soval, ret;
         uc_value_t *level, *option, *value;
         void *valptr = NULL, *st = NULL;
         socklen_t vallen = 0;
         size_t i;
 
         args_get(vm, nargs, &sockfd,
                 "level", UC_INTEGER, false, &level,
                 "option", UC_INTEGER, false, &option,
                 "value", UC_NULL, false, &value);
 
         solvl = ucv_int64_get(level);
         soopt = ucv_int64_get(option);
 
         for (i = 0; i < ARRAY_SIZE(sockopts); i++) {
                 if (sockopts[i].level != solvl || sockopts[i].option != soopt)
                         continue;
 
                 switch ((uintptr_t)sockopts[i].ctype) {
                 case (uintptr_t)SV_INT_RO:
                         err_return(EOPNOTSUPP, "Socket option is read only");
 
                 case (uintptr_t)SV_VOID:
                         valptr = NULL;
                         vallen = 0;
                         break;
 
                 case (uintptr_t)SV_INT:
                         soval = ucv_to_integer(value);
 
                         if (errno)
                                 err_return(errno, "Unable to convert value to integer");
 
                         valptr = &soval;
                         vallen = sizeof(int);
                         break;
 
                 case (uintptr_t)SV_BOOL:
                         soval = ucv_to_unsigned(value) ? 1 : 0;
 
                         if (errno)
                                 err_return(errno, "Unable to convert value to boolean");
 
                         valptr = &soval;
                         vallen = sizeof(int);
                         break;
 
                 case (uintptr_t)SV_STRING:
                         valptr = ucv_string_get(value);
                         vallen = ucv_string_length(value);
                         break;
 
                 case (uintptr_t)SV_IFNAME:
                         if (ucv_type(value) == UC_STRING) {
                                 soval = if_nametoindex(ucv_string_get(value));
 
                                 if (soval <= 0)
                                         err_return(errno, "Unable to resolve interface %s",
                                                 ucv_string_get(value));
                         }
                         else {
                                 soval = ucv_to_integer(value);
 
                                 if (errno)
                                         err_return(errno, "Unable to convert value to integer");
                         }
 
                         valptr = &soval;
                         vallen = sizeof(int);
                         break;
 
                 default:
                         st = uv_to_struct(value, sockopts[i].ctype);
                         valptr = st;
                         vallen = sockopts[i].ctype->size;
                         break;
                 }
 
                 break;
         }
 
         if (i == ARRAY_SIZE(sockopts))
                 err_return(EINVAL, "Unknown socket level or option");
 
         ret = setsockopt(sockfd, solvl, soopt, valptr, vallen);
 
         free(st);
 
         if (ret == -1)
                 err_return(errno, "setsockopt()");
 
         ok_return(ucv_boolean_new(true));
 }
 
 /**
  * Gets options from the socket.
  *
  * Retrieves the value of the specified option from the socket.
  *
  * Returns the value of the requested option.
  *
  * Returns `null` if an error occurred or if the option is not supported.
  *
  * @function module:socket.socket#getopt
  *
  * @param {number} level
  * The protocol level at which the option resides. This can be a level such as
  * `SOL_SOCKET` for the socket API level or a specific protocol level defined
  * by the system.
  *
  * @param {number} option
  * The socket option to retrieve. This can be an integer representing the
  * option, such as `SO_REUSEADDR`, or a constant defined by the system.
  *
  * @returns {?*}
  * The value of the requested option. The type of the returned value depends
  * on the specific option being retrieved. It can be an integer, a boolean, a
  * string, or a dictionary representing a complex data structure.
  */
 static uc_value_t *
 uc_socket_inst_getopt(uc_vm_t *vm, size_t nargs)
 {
         uc_value_t *level, *option, *value = NULL;
         char ival[sizeof(int64_t)] = { 0 };
         void *valptr = NULL, *st = NULL;
         int sockfd, solvl, soopt, ret;
         uc_stringbuf_t *sb = NULL;
         socklen_t vallen;
         size_t i;
 
         args_get(vm, nargs, &sockfd,
                 "level", UC_INTEGER, false, &level,
                 "option", UC_INTEGER, false, &option);
 
         solvl = ucv_int64_get(level);
         soopt = ucv_int64_get(option);
 
         for (i = 0; i < ARRAY_SIZE(sockopts); i++) {
                 if (sockopts[i].level != solvl || sockopts[i].option != soopt)
                         continue;
 
                 switch ((uintptr_t)sockopts[i].ctype) {
                 case (uintptr_t)SV_VOID:
                         err_return(EOPNOTSUPP, "Socket option is write only");
 
                 case (uintptr_t)SV_INT:
                 case (uintptr_t)SV_INT_RO:
                 case (uintptr_t)SV_BOOL:
                 case (uintptr_t)SV_IFNAME:
                         valptr = ival;
                         vallen = sizeof(ival);
                         break;
 
                 case (uintptr_t)SV_STRING:
                         sb = strbuf_alloc(64);
                         valptr = strbuf_data(sb);
                         vallen = strbuf_size(sb);
                         break;
 
                 default:
                         st = xalloc(sockopts[i].ctype->size);
                         valptr = st;
                         vallen = sockopts[i].ctype->size;
                         break;
                 }
 
                 break;
         }
 
         if (i == ARRAY_SIZE(sockopts))
                 err_return(EINVAL, "Unknown socket level or option");
 
         while (true) {
                 ret = getsockopt(sockfd, solvl, soopt, valptr, &vallen);
 
                 if (sockopts[i].ctype == SV_STRING &&
                     (ret == 0 || (ret == -1 && errno == ERANGE)) &&
                     vallen > strbuf_size(sb)) {
 
                         if (!strbuf_grow(sb, vallen))
                                 return NULL;
 
                         valptr = strbuf_data(sb);
                         continue;
                 }
 
                 break;
         }
 
         if (ret == 0) {
                 char ifname[IF_NAMESIZE];
                 int ifidx;
 
                 switch ((uintptr_t)sockopts[i].ctype) {
                 case (uintptr_t)SV_VOID:
                         break;
 
                 case (uintptr_t)SV_INT:
                 case (uintptr_t)SV_INT_RO:
                         value = ucv_int64_new(parse_integer(ival, vallen));
                         break;
 
                 case (uintptr_t)SV_BOOL:
                         value = ucv_boolean_new(parse_integer(ival, vallen) != 0);
                         break;
 
                 case (uintptr_t)SV_STRING:
                         value = strbuf_finish(&sb, vallen);
                         break;
 
                 case (uintptr_t)SV_IFNAME:
                         ifidx = parse_integer(ival, vallen);
                         if (if_indextoname(ifidx, ifname))
                                 value = ucv_string_new(ifname);
                         else
                                 value = ucv_int64_new(ifidx);
                         break;
 
                 default:
                         value = struct_to_uv(st, sockopts[i].ctype);
                         break;
                 }
         }
 
         strbuf_free(sb);
         free(st);
 
         if (ret == -1)
                 err_return(errno, "getsockopt()");
 
         ok_return(value);
 }
 
 /**
  * Returns the UNIX file descriptor number associated with the socket.
  *
  * Returns the file descriptor number.
  *
  * Returns `-1` if an error occurred.
  *
  * @function module:socket.socket#fileno
  *
  * @returns {number}
  */
 static uc_value_t *
 uc_socket_inst_fileno(uc_vm_t *vm, size_t nargs)
 {
         int sockfd;
 
         args_get(vm, nargs, &sockfd);
 
         ok_return(ucv_int64_new(sockfd));
 }
 
 /**
  * Query error information.
  *
  * Returns a string containing a description of the last occurred error when
  * the *numeric* argument is absent or false.
  *
  * Returns a positive (`errno`) or negative (`EAI_*` constant) error code number
  * when the *numeric* argument is `true`.
  *
  * Returns `null` if there is no error information.
  *
  * @function module:socket#error
  *
  * @param {boolean} [numeric]
  * Whether to return a numeric error code (`true`) or a human readable error
  * message (false).
  *
  * @returns {?string|?number}
  *
  * @example
  * // Trigger socket error by attempting to bind IPv6 address with IPv4 socket
  * socket.create(socket.AF_INET, socket.SOCK_STREAM, 0).bind("::", 8080);
  *
  * // Print error (should yield "Address family not supported by protocol")
  * print(socket.error(), "\n");
  *
  * // Trigger resolve error
  * socket.addrinfo("doesnotexist.org");
  *
  * // Query error code (should yield -2 for EAI_NONAME)
  * print(socket.error(true), "\n");  //
  */
 static uc_value_t *
 uc_socket_error(uc_vm_t *vm, size_t nargs)
 {
         uc_value_t *numeric = uc_fn_arg(0), *rv;
         uc_stringbuf_t *buf;
 
         if (last_error.code == 0)
                 return NULL;
 
         if (ucv_is_truish(numeric)) {
                 rv = ucv_int64_new(last_error.code);
         }
         else {
                 buf = ucv_stringbuf_new();
 
                 if (last_error.msg)
                         ucv_stringbuf_printf(buf, "%s: ", last_error.msg);
 
                 if (last_error.code >= 0)
                         ucv_stringbuf_printf(buf, "%s", strerror(last_error.code));
                 else
                         ucv_stringbuf_printf(buf, "%s", gai_strerror(last_error.code));
 
                 rv = ucv_stringbuf_finish(buf);
         }
 
         ok_return(rv);
 }
 
 /**
  * @typedef {Object} module:socket.socket.SocketAddress
  * @property {number} family
  * Address family, one of AF_INET, AF_INET6, AF_UNIX or AF_PACKET.
  *
  * @property {string} address
  * IPv4/IPv6 address string (AF_INET or AF_INET6 only) or hardware address in
  * hexadecimal notation (AF_PACKET only).
  *
  * @property {number} [port]
  * Port number (AF_INET or AF_INET6 only).
  *
  * @property {number} [flowinfo]
  * IPv6 flow information (AF_INET6 only).
  *
  * @property {string|number} [interface]
  * Link local address scope (for IPv6 sockets) or bound network interface
  * (for packet sockets), either a network device name string or a nonzero
  * positive integer representing a network interface index (AF_INET6 and
  * AF_PACKET only).
  *
  * @property {string} path
  * Domain socket filesystem path (AF_UNIX only).
  *
  * @property {number} [protocol=0]
  * Physical layer protocol (AF_PACKET only).
  *
  * @property {number} [hardware_type=0]
  * ARP hardware type (AF_PACKET only).
  *
  * @property {number} [packet_type=PACKET_HOST]
  * Packet type (AF_PACKET only).
  */
 
 /**
  * Parses the provided address value into a socket address representation.
  *
  * This function parses the given address value into a socket address
  * representation required for a number of socket operations. The address value
  * can be provided in various formats:
  * - For IPv4 addresses, it can be a string representing the IP address,
  *   optionally followed by a port number separated by colon, e.g.
  *   `192.168.0.1:8080`.
  * - For IPv6 addresses, it must be an address string enclosed in square
  *   brackets if a port number is specified, otherwise the brackets are
  *   optional. The address string may also include a scope ID in the form
  *   `%ifname` or `%number`, e.g. `[fe80::1%eth0]:8080` or `fe80::1%15`.
  * - Any string value containing a slash is treated as UNIX domain socket path.
  * - Alternatively, it can be provided as an array returned by
  *   {@link module:core#iptoarr|iptoarr()}, representing the address octets.
  * - It can also be an object representing a network address, with properties
  *   for `address` (the IP address) and `port` or a single property `path` to
  *   denote a UNIX domain socket address.
  *
  * @function module:socket#sockaddr
  *
  * @param {string|number[]|module:socket.socket.SocketAddress} address
  * The address value to parse.
  *
  * @returns {?module:socket.socket.SocketAddress}
  * A socket address representation of the provided address value, or `null` if
  * the address could not be parsed.
  *
  * @example
  * // Parse an IP address string with port
  * const address1 = sockaddr('192.168.0.1:8080');
  *
  * // Parse an IPv6 address string with port and scope identifier
  * const address2 = sockaddr('[fe80::1%eth0]:8080');
  *
  * // Parse an array representing an IP address
  * const address3 = sockaddr([192, 168, 0, 1]);
  *
  * // Parse a network address object
  * const address4 = sockaddr({ address: '192.168.0.1', port: 8080 });
  *
  * // Convert a path value to a UNIX domain socket address
  * const address5 = sockaddr('/var/run/daemon.sock');
  */
 static uc_value_t *
 uc_socket_sockaddr(uc_vm_t *vm, size_t nargs)
 {
         struct sockaddr_storage ss = { 0 };
         uc_value_t *addr, *rv;
         socklen_t slen;
 
         args_get(vm, nargs, NULL,
                 "address", UC_NULL, false, &addr);
 
         if (!uv_to_sockaddr(addr, &ss, &slen))
                 return NULL;
 
         rv = ucv_object_new(vm);
 
         if (!sockaddr_to_uv(&ss, rv)) {
                 ucv_put(rv);
                 return NULL;
         }
 
         ok_return(rv);
 }
 
 /**
  * Resolves the given network address into hostname and service name.
  *
  * The `nameinfo()` function provides an API for reverse DNS lookup and service
  * name resolution. It returns an object containing the following properties:
  * - `hostname`: The resolved hostname.
  * - `service`: The resolved service name.
  *
  * Returns an object representing the resolved hostname and service name.
  * Return `null` if an error occurred during resolution.
  *
  * @function module:socket#nameinfo
  *
  * @param {string|module:socket.socket.SocketAddress} address
  * The network address to resolve. It can be specified as:
  * - A string representing the IP address.
  * - An object representing the address with properties `address` and `port`.
  *
  * @param {number} [flags]
  * Optional flags that provide additional control over the resolution process,
  * specified as bitwise OR-ed number of `NI_*` constants.
  *
  * @returns {?{hostname: string, service: string}}
  *
  * @see {@link module:socket~"Socket Types"|Socket Types}
  * @see {@link module:socket~"Name Info Constants"|AName Info Constants}
  *
  * @example
  * // Resolve a network address into hostname and service name
  * const result = network.getnameinfo('192.168.1.1:80');
  * print(result); // { "hostname": "example.com", "service": "http" }
  */
 static uc_value_t *
 uc_socket_nameinfo(uc_vm_t *vm, size_t nargs)
 {
         char host[NI_MAXHOST], serv[NI_MAXSERV];
         uc_value_t *addr, *flags, *rv;
         struct sockaddr_storage ss;
         socklen_t slen;
         int ret;
 
         args_get(vm, nargs, NULL,
                 "address", UC_NULL, false, &addr,
                 "flags", UC_INTEGER, true, &flags);
 
         if (!uv_to_sockaddr(addr, &ss, &slen))
                 return NULL;
 
         ret = getnameinfo((struct sockaddr *)&ss, slen,
                 host, sizeof(host), serv, sizeof(serv),
                 flags ? ucv_int64_get(flags) : 0);
 
         if (ret != 0)
                 err_return((ret == EAI_SYSTEM) ? errno : ret, "getnameinfo()");
 
         rv = ucv_object_new(vm);
 
         ucv_object_add(rv, "hostname", ucv_string_new(host));
         ucv_object_add(rv, "service", ucv_string_new(serv));
 
         ok_return(rv);
 }
 
 /**
  * Resolves the given hostname and optional service name into a list of network
  * addresses, according to the provided hints.
  *
  * The `addrinfo()` function provides an API for performing DNS and service name
  * resolution. It returns an array of objects, each representing a resolved
  * address.
  *
  * Returns an array of resolved addresses.
  * Returns `null` if an error occurred during resolution.
  *
  * @function module:socket#addrinfo
  *
  * @param {string} hostname
  * The hostname to resolve.
  *
  * @param {string} [service]
  * Optional service name to resolve. If not provided, the service field of the
  * resulting address information structures is left uninitialized.
  *
  * @param {Object} [hints]
  * Optional hints object that provides additional control over the resolution
  * process. It can contain the following properties:
  * - `family`: The preferred address family (`AF_INET` or `AF_INET6`).
  * - `socktype`: The socket type (`SOCK_STREAM`, `SOCK_DGRAM`, etc.).
  * - `protocol`: The protocol of returned addresses.
  * - `flags`: Bitwise OR-ed `AI_*` flags to control the resolution behavior.
  *
  * @returns {?module:socket.AddressInfo[]}
  *
  * @see {@link module:socket~"Socket Types"|Socket Types}
  * @see {@link module:socket~"Address Info Flags"|Address Info Flags}
  *
  * @example
  * // Resolve all addresses
  * const addresses = socket.addrinfo('example.org');
  *
  * // Resolve IPv4 addresses for a given hostname and service
  * const ipv4addresses = socket.addrinfo('example.com', 'http', { family: socket.AF_INET });
  *
  * // Resolve IPv6 addresses without specifying a service
  * const ipv6Addresses = socket.addrinfo('example.com', null, { family: socket.AF_INET6 });
  */
 
 static uc_value_t *
 uc_socket_addrinfo(uc_vm_t *vm, size_t nargs)
 {
         struct addrinfo *ai_hints = NULL, *ai_res;
         uc_value_t *host, *serv, *hints, *rv;
         char *servstr;
         int ret;
 
         args_get(vm, nargs, NULL,
                 "hostname", UC_STRING, false, &host,
                 "service", UC_NULL, true, &serv,
                 "hints", UC_OBJECT, true, &hints);
 
         if (hints) {
                 ai_hints = (struct addrinfo *)uv_to_struct(hints, &st_addrinfo);
 
                 if (!ai_hints)
                         return NULL;
         }
 
         servstr = (serv && ucv_type(serv) != UC_STRING) ? ucv_to_string(vm, serv) : NULL;
         ret = getaddrinfo(ucv_string_get(host),
                 servstr ? servstr : ucv_string_get(serv),
                 ai_hints, &ai_res);
 
         free(ai_hints);
         free(servstr);
 
         if (ret != 0)
                 err_return((ret == EAI_SYSTEM) ? errno : ret, "getaddrinfo()");
 
         rv = ucv_array_new(vm);
 
         for (struct addrinfo *ai = ai_res; ai; ai = ai->ai_next) {
                 uc_value_t *item = struct_to_uv((char *)ai, &st_addrinfo);
 
                 if (item)
                         ucv_array_push(rv, item);
         }
 
         freeaddrinfo(ai_res);
 
         ok_return(rv);
 }
 
 /**
  * Represents a poll state serving as input parameter and return value type for
  * {@link module:socket#poll|`poll()`}.
  *
  * @typedef {Array} module:socket.PollSpec
  * @property {module:socket.socket} 0
  * The polled socket instance.
  *
  * @property {number} 1
  * Requested or returned status flags of the polled socket instance.
  */
 
 /**
  * Polls a number of sockets for state changes.
  *
  * Returns an array of `[socket, flags]` tuples for each socket with pending
  * events. When a tuple is passed as socket argument, it is included as-is into
  * the result tuple array, with the flags entry changed to a bitwise OR-ed value
  * describing the pending events for this socket. When a plain socket instance
  * (or another kind of handle) is passed, a new tuple array is created for this
  * socket within the result tuple array, containing this socket as first and the
  * bitwise OR-ed pending events as second element.
  *
  * Returns `null` if an error occurred.
  *
  * @function module:socket#poll
  *
  * @param {number} timeout
  * Amount of milliseconds to wait for socket activity before aborting the poll
  * call. If set to `0`, the poll call will return immediately if none of the
  * provided sockets has pending events, if set to a negative value, the poll
  * call will wait indefinitely, in all other cases the poll call will wait at
  * most for the given amount of milliseconds before returning.
  *
  * @param {...(module:socket.socket|module:socket.PollSpec)} sockets
  * An arbitrary amount of socket arguments. Each argument may be either a plain
  * {@link module:socket.socket|socket instance} (or any other kind of handle
  * implementing a `fileno()` method) or a `[socket, flags]` tuple specifying the
  * socket and requested poll flags. If a plain socket (or other kind of handle)
  * instead of a tuple is provided, the requested poll flags default to
  * `POLLIN|POLLERR|POLLHUP` for this socket.
  *
  * @returns {module:socket.PollSpec[]}
  *
  * @example
  * let x = socket.connect("example.org", 80);
  * let y = socket.connect("example.com", 80);
  *
  * // Pass plain socket arguments
  * let events = socket.poll(10, x, y);
  * print(events); // [ [ "<socket 0x7>", 0 ], [ "<socket 0x8>", 0 ] ]
  *
  * // Passing tuples allows attaching state information and requesting
  * // different I/O events
  * let events = socket.poll(10,
  *      [ x, socket.POLLOUT | socket.POLLHUP, "This is example.org" ],
  *      [ y, socket.POLLOUT | socket.POLLHUP, "This is example.com" ]
  * );
  * print(events); // [ [ "<socket 0x7>", 4, "This is example.org" ],
  *                //   [ "<socket 0x8>", 4, "This is example.com" ] ]
  */
 static uc_value_t *
 uc_socket_poll(uc_vm_t *vm, size_t nargs)
 {
         struct { struct pollfd *entries; size_t count; } pfds = { 0 };
         uc_value_t *timeoutarg, *rv, *item;
         int64_t timeout;
         int ret;
 
         args_get(vm, nargs, NULL, "timeout", UC_INTEGER, false, &timeoutarg);
 
         timeout = ucv_to_integer(timeoutarg);
 
         if (errno != 0 || timeout < (int64_t)INT_MIN || timeout > (int64_t)INT_MAX)
                 err_return(ERANGE, "Invalid timeout value");
 
         rv = ucv_array_new(vm);
 
         for (size_t i = 1; i < nargs; i++) {
                 uc_vector_grow(&pfds);
                 item = uv_to_pollfd(vm, uc_fn_arg(i), &pfds.entries[pfds.count]);
 
                 if (item)
                         ucv_array_set(rv, pfds.count++, item);
         }
 
         ret = poll(pfds.entries, pfds.count, timeout);
 
         if (ret == -1) {
                 ucv_put(rv);
                 uc_vector_clear(&pfds);
                 err_return(errno, "poll()");
         }
 
         for (size_t i = 0; i < pfds.count; i++)
                 ucv_array_set(ucv_array_get(rv, i), 1,
                         ucv_int64_new(pfds.entries[i].revents));
 
         uc_vector_clear(&pfds);
         ok_return(rv);
 }
 
 static bool
 should_resolve(uc_value_t *host)
 {
         char *s = ucv_string_get(host);
 
         return (s != NULL && memchr(s, '/', ucv_string_length(host)) == NULL);
 }
 
 /**
  * Creates a network socket and connects it to the specified host and service.
  *
  * This high level function combines the functionality of
  * {@link module:socket#create|create()},
  * {@link module:socket#addrinfo|addrinfo()} and
  * {@link module:socket.socket#connect|connect()} to simplify connection
  * establishment with the socket module.
  *
  * @function module:socket#connect
  *
  * @param {string|number[]|module:socket.socket.SocketAddress} host
  * The host to connect to, can be an IP address, hostname,
  * {@link module:socket.socket.SocketAddress|SocketAddress}, or an array value
  * returned by {@link module:core#iptoarr|iptoarr()}.
  *
  * @param {string|number} [service]
  * The service to connect to, can be a symbolic service name (such as "http") or
  * a port number. Optional if host is specified as
  * {@link module:socket.socket.SocketAddress|SocketAddress}.
  *
  * @param {Object} [hints]
  * Optional preferences for the socket. It can contain the following properties:
  * - `family`: The preferred address family (`AF_INET` or `AF_INET6`).
  * - `socktype`: The socket type (`SOCK_STREAM`, `SOCK_DGRAM`, etc.).
  * - `protocol`: The protocol of the created socket.
  * - `flags`: Bitwise OR-ed `AI_*` flags to control the resolution behavior.
  *
  * If no hints are not provided, the default socket type preference is set to
  * `SOCK_STREAM`.
  *
  * @param {number} [timeout=-1]
  * The timeout in milliseconds for socket connect operations. If set to a
  * negative value, no specifc time limit is imposed and the function will
  * block until either a connection was successfull or the underlying operating
  * system timeout is reached.
  *
  * @returns {module:socket.socket}
  *
  * @example
  * // Resolve host, try to connect to both resulting IPv4 and IPv6 addresses
  * let conn = socket.connect("example.org", 80);
  *
  * // Enforce usage of IPv6
  * let conn = socket.connect("example.com", 80, { family: socket.AF_INET6 });
  *
  * // Connect a UDP socket
  * let conn = socket.connect("192.168.1.1", 53, { socktype: socket.SOCK_DGRAM });
  *
  * // Bypass name resolution by specifying a SocketAddress structure
  * let conn = socket.connect({ address: "127.0.0.1", port: 9000 });
  *
  * // Use SocketAddress structure to connect a UNIX domain socket
  * let conn = socket.connect({ path: "/var/run/daemon.sock" });
  */
 static uc_value_t *
 uc_socket_connect(uc_vm_t *vm, size_t nargs)
 {
         struct address {
                 struct sockaddr_storage ss;
                 struct addrinfo ai;
                 int flags;
                 int fd;
         } *ap;
 
         struct { struct address *entries; size_t count; } addresses = { 0 };
         struct { struct pollfd *entries; size_t count; } pollfds = { 0 };
         struct addrinfo *ai_results, *ai_hints, *ai;
         uc_value_t *host, *serv, *hints, *timeout;
         const char *errmsg = NULL;
         struct pollfd *pp = NULL;
         size_t slot, connected;
         int ret, err;
 
         args_get(vm, nargs, NULL,
                 "host", UC_NULL, false, &host,
                 "service", UC_NULL, true, &serv,
                 "hints", UC_OBJECT, true, &hints,
                 "timeout", UC_INTEGER, true, &timeout);
 
         ai_hints = hints
                 ? (struct addrinfo *)uv_to_struct(hints, &st_addrinfo) : NULL;
 
         if (should_resolve(host)) {
                 char *servstr = (ucv_type(serv) != UC_STRING)
                         ? ucv_to_string(vm, serv) : NULL;
 
                 ret = getaddrinfo(ucv_string_get(host),
                         servstr ? servstr : ucv_string_get(serv),
                         ai_hints ? ai_hints : &(struct addrinfo){
                                 .ai_socktype = SOCK_STREAM
                         }, &ai_results);
 
                 if (ret != 0) {
                         free(servstr);
                         free(ai_hints);
                         err_return((ret == EAI_SYSTEM) ? errno : ret,
                                 "getaddrinfo()");
                 }
 
                 for (ai = ai_results; ai != NULL; ai = ai->ai_next) {
                         if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6)
                                 continue;
 
                         uc_vector_grow(&addresses);
                         ap = &addresses.entries[addresses.count++];
                         memcpy(&ap->ss, ai->ai_addr, ai->ai_addrlen);
                         memcpy(&ap->ai, ai, sizeof(*ai));
                         ap->ai.ai_addr = (struct sockaddr *)&ap->ss;
                 }
 
                 freeaddrinfo(ai_results);
                 free(servstr);
         }
         else {
                 uc_vector_grow(&addresses);
                 ap = &addresses.entries[addresses.count++];
 
                 if (!uv_to_sockaddr(host, &ap->ss, &ap->ai.ai_addrlen)) {
                         free(ai_hints);
                         uc_vector_clear(&addresses);
                         return NULL;
                 }
 
                 if (serv) {
                         uint64_t port = ucv_to_unsigned(serv);
 
                         if (port > 65535)
                                 errno = ERANGE;
 
                         if (errno != 0) {
                                 free(ai_hints);
                                 uc_vector_clear(&addresses);
                                 err_return(errno, "Invalid port number");
                         }
 
                         ((struct sockaddr_in *)&ap->ss)->sin_port = htons(port);
                 }
 
                 ap->ai.ai_addr = (struct sockaddr *)&ap->ss;
                 ap->ai.ai_family = ap->ss.ss_family;
                 ap->ai.ai_socktype = ai_hints ? ai_hints->ai_socktype : SOCK_STREAM;
                 ap->ai.ai_protocol = ai_hints ? ai_hints->ai_protocol : 0;
         }
 
         free(ai_hints);
 
         for (connected = 0, slot = 0, ap = &addresses.entries[slot];
              slot < addresses.count;
              slot++, ap = &addresses.entries[slot])
         {
                 uc_vector_grow(&pollfds);
                 pp = &pollfds.entries[pollfds.count++];
                 pp->events = POLLIN | POLLOUT | POLLHUP | POLLERR;
                 pp->fd = socket(ap->ai.ai_family, ap->ai.ai_socktype, ap->ai.ai_protocol);
 
                 if (pp->fd == -1)
                         continue;
 
                 if ((ap->flags = fcntl(pp->fd, F_GETFL, 0)) == -1) {
                         xclose(&pp->fd);
                         continue;
                 }
 
                 if (fcntl(pp->fd, F_SETFL, ap->flags | O_NONBLOCK) == -1) {
                         xclose(&pp->fd);
                         continue;
                 }
 
                 ret = connect(pp->fd, ap->ai.ai_addr, ap->ai.ai_addrlen);
 
                 if (ret == -1 && errno != EINPROGRESS) {
                         xclose(&pp->fd);
                         continue;
                 }
 
                 connected++;
         }
 
         if (connected == 0) {
                 err = EAI_NONAME;
                 errmsg = "Could not connect to any host address";
                 goto out;
         }
 
         ret = poll(pollfds.entries, pollfds.count,
                 timeout ? ucv_int64_get(timeout) : -1);
 
         if (ret == -1) {
                 err = errno;
                 errmsg = "poll()";
                 goto out;
         }
 
         for (slot = 0, ap = NULL, pp = NULL; slot < pollfds.count; slot++) {
                 if (pollfds.entries[slot].revents & (POLLIN|POLLOUT)) {
                         ap = &addresses.entries[slot];
                         pp = &pollfds.entries[slot];
                         break;
                 }
         }
 
         if (!ap) {
                 err = ETIMEDOUT;
                 errmsg = "Connection timed out";
                 goto out;
         }
 
         if (fcntl(pp->fd, F_SETFL, ap->flags) == -1) {
                 err = errno;
                 errmsg = "fcntl(F_SETFL)";
                 goto out;
         }
 
 out:
         for (slot = 0, ret = -1; slot < pollfds.count; slot++) {
                 if (pp == &pollfds.entries[slot])
                         ret = pollfds.entries[slot].fd;
                 else
                         xclose(&pollfds.entries[slot].fd);
         }
 
         uc_vector_clear(&addresses);
         uc_vector_clear(&pollfds);
 
         if (errmsg)
                 err_return(err, "%s", errmsg);
 
         ok_return(ucv_socket_new(vm, ret));
 }
 
 /**
  * Binds a listening network socket to the specified host and service.
  *
  * This high-level function combines the functionality of
  * {@link module:socket#create|create()},
  * {@link module:socket#addrinfo|addrinfo()},
  * {@link module:socket.socket#bind|bind()}, and
  * {@link module:socket.socket#listen|listen()} to simplify setting up a
  * listening socket with the socket module.
  *
  * @function module:socket#listen
  *
  * @param {string|number[]|module:socket.socket.SocketAddress} host
  * The host to bind to, can be an IP address, hostname,
  * {@link module:socket.socket.SocketAddress|SocketAddress}, or an array value
  * returned by {@link module:core#iptoarr|iptoarr()}.
  *
  * @param {string|number} [service]
  * The service to listen on, can be a symbolic service name (such as "http") or
  * a port number. Optional if host is specified as
  * {@link module:socket.socket.SocketAddress|SocketAddress}.
  *
  * @param {Object} [hints]
  * Optional preferences for the socket. It can contain the following properties:
  * - `family`: The preferred address family (`AF_INET` or `AF_INET6`).
  * - `socktype`: The socket type (`SOCK_STREAM`, `SOCK_DGRAM`, etc.).
  * - `protocol`: The protocol of the created socket.
  * - `flags`: Bitwise OR-ed `AI_*` flags to control the resolution behavior.
  *
  * If no hints are provided, the default socket type preference is set to
  * `SOCK_STREAM`.
  *
  * @param {number} [backlog=128]
  * The maximum length of the queue of pending connections.
  *
  * @returns {module:socket.socket}
  *
  * @example
  * // Listen for incoming TCP connections on port 80
  * let server = socket.listen("localhost", 80);
  *
  * // Listen on IPv6 address only
  * let server = socket.listen("machine.local", 8080, { family: socket.AF_INET6 });
  *
  * // Listen on a UNIX domain socket
  * let server = socket.listen({ path: "/var/run/server.sock" });
  */
 static uc_value_t *
 uc_socket_listen(uc_vm_t *vm, size_t nargs)
 {
         int ret, fd, curr_weight, prev_weight, socktype = 0, protocol = 0;
         struct addrinfo *ai_results, *ai_hints, *ai;
         uc_value_t *host, *serv, *hints, *backlog;
         struct sockaddr_storage ss = { 0 };
         bool v6, lo, ll;
         socklen_t slen;
 
         args_get(vm, nargs, NULL,
                 "host", UC_NULL, true, &host,
                 "service", UC_NULL, true, &serv,
                 "hints", UC_OBJECT, true, &hints,
                 "backlog", UC_INTEGER, true, &backlog);
 
         ai_hints = hints
                 ? (struct addrinfo *)uv_to_struct(hints, &st_addrinfo) : NULL;
 
         if (host == NULL || should_resolve(host)) {
                 char *servstr = (ucv_type(serv) != UC_STRING)
                         ? ucv_to_string(vm, serv) : NULL;
 
                 ret = getaddrinfo(ucv_string_get(host),
                         servstr ? servstr : ucv_string_get(serv),
                         ai_hints ? ai_hints : &(struct addrinfo){
                                 .ai_flags = AI_PASSIVE | AI_ADDRCONFIG,
                                 .ai_socktype = SOCK_STREAM
                         }, &ai_results);
 
                 free(servstr);
 
                 if (ret != 0) {
                         free(ai_hints);
                         err_return((ret == EAI_SYSTEM) ? errno : ret,
                                 "getaddrinfo()");
                 }
 
                 for (ai = ai_results, prev_weight = -1; ai != NULL; ai = ai->ai_next) {
                         struct sockaddr_in6 *s6 = (struct sockaddr_in6 *)ai->ai_addr;
                         struct sockaddr_in *s4 = (struct sockaddr_in *)ai->ai_addr;
 
                         v6 = (s6->sin6_family == AF_INET6);
                         ll = v6
                                 ? IN6_IS_ADDR_LINKLOCAL(&s6->sin6_addr)
                                 : ((ntohl(s4->sin_addr.s_addr) & 0xffff0000) == 0xa9fe0000);
                         lo = v6
                                 ? IN6_IS_ADDR_LOOPBACK(&s6->sin6_addr)
                                 : ((ntohl(s4->sin_addr.s_addr) & 0xff000000) == 0x7f000000);
 
                         curr_weight = (!lo << 2) | (v6 << 1) | (!ll << 0);
 
                         if (curr_weight > prev_weight) {
                                 prev_weight = curr_weight;
                                 socktype = ai->ai_socktype;
                                 protocol = ai->ai_protocol;
                                 slen     = ai->ai_addrlen;
                                 memcpy(&ss, ai->ai_addr, slen);
                         }
                 }
 
                 freeaddrinfo(ai_results);
         }
         else {
                 if (!uv_to_sockaddr(host, &ss, &slen)) {
                         free(ai_hints);
                         return NULL;
                 }
 
                 if (serv) {
                         uint64_t port = ucv_to_unsigned(serv);
 
                         if (port > 65535)
                                 errno = ERANGE;
 
                         if (errno != 0) {
                                 free(ai_hints);
                                 err_return(errno, "Invalid port number");
                         }
 
                         ((struct sockaddr_in *)&ss)->sin_port = htons(port);
                 }
 
                 int default_socktype = SOCK_STREAM;
 
                 if (ss.ss_family != AF_INET && ss.ss_family != AF_INET6)
                         default_socktype = SOCK_DGRAM;
 
                 socktype = ai_hints ? ai_hints->ai_socktype : default_socktype;
                 protocol = ai_hints ? ai_hints->ai_protocol : 0;
         }
 
         free(ai_hints);
 
         if (ss.ss_family == AF_UNSPEC)
                 err_return(EAI_NONAME, "Could not resolve host address");
 
         fd = socket(ss.ss_family, socktype, protocol);
 
         if (fd == -1)
                 err_return(errno, "socket()");
 
         ret = bind(fd, (struct sockaddr *)&ss, slen);
 
         if (ret == -1) {
                 close(fd);
                 err_return(errno, "bind()");
         }
 
         ret = listen(fd, backlog ? ucv_to_unsigned(backlog) : 128);
 
         if (ret == -1 && errno != EOPNOTSUPP) {
                 close(fd);
                 err_return(errno, "listen()");
         }
 
         ok_return(ucv_socket_new(vm, fd));
 }
 
 /**
  * Represents a socket handle.
  *
  * @class module:socket.socket
  * @hideconstructor
  *
  * @borrows module:socket#error as module:socket.socket#error
  *
  * @see {@link module:socket#create|create()}
  *
  * @example
  *
  * const sock = create(…);
  *
  * sock.getopt(…);
  * sock.setopt(…);
  *
  * sock.connect(…);
  * sock.listen(…);
  * sock.accept(…);
  * sock.bind(…);
  *
  * sock.send(…);
  * sock.recv(…);
  *
  * sock.shutdown(…);
  *
  * sock.fileno();
  * sock.peername();
  * sock.sockname();
  *
  * sock.close();
  *
  * sock.error();
  */
 
 /**
  * Creates a network socket instance.
  *
  * This function creates a new network socket with the specified domain and
  * type, determined by one of the modules `AF_*` and `SOCK_*` constants
  * respectively, and returns the resulting socket instance for use in subsequent
  * socket operations.
  *
  * The domain argument specifies the protocol family, such as AF_INET or
  * AF_INET6, and defaults to AF_INET if not provided.
  *
  * The type argument specifies the socket type, such as SOCK_STREAM or
  * SOCK_DGRAM, and defaults to SOCK_STREAM if not provided. It may also
  * be bitwise OR-ed with SOCK_NONBLOCK to enable non-blocking mode or
  * SOCK_CLOEXEC to enable close-on-exec semantics.
  *
  * The protocol argument may be used to indicate a particular protocol
  * to be used with the socket, and it defaults to 0 (automatically
  * determined protocol) if not provided.
  *
  * Returns a socket descriptor representing the newly created socket.
  *
  * Returns `null` if an error occurred during socket creation.
  *
  * @function module:socket#create
  *
  * @param {number} [domain=AF_INET]
  * The communication domain for the socket, e.g., AF_INET or AF_INET6.
  *
  * @param {number} [type=SOCK_STREAM]
  * The socket type, e.g., SOCK_STREAM or SOCK_DGRAM. It may also be
  * bitwise OR-ed with SOCK_NONBLOCK or SOCK_CLOEXEC.
  *
  * @param {number} [protocol=0]
  * The protocol to be used with the socket.
  *
  * @returns {?module:socket.socket}
  * A socket instance representing the newly created socket.
  *
  * @example
  * // Create a TCP socket
  * const tcp_socket = create(AF_INET, SOCK_STREAM);
  *
  * // Create a nonblocking IPv6 UDP socket
  * const udp_socket = create(AF_INET6, SOCK_DGRAM | SOCK_NONBLOCK);
  */
 static uc_value_t *
 uc_socket_create(uc_vm_t *vm, size_t nargs)
 {
         uc_value_t *domain, *type, *protocol;
         int sockfd, socktype;
 
         args_get(vm, nargs, NULL,
                 "domain", UC_INTEGER, true, &domain,
                 "type", UC_INTEGER, true, &type,
                 "protocol", UC_INTEGER, true, &protocol);
 
         socktype = type ? (int)ucv_int64_get(type) : SOCK_STREAM;
 
         sockfd = socket(
                 domain ? (int)ucv_int64_get(domain) : AF_INET,
 #if defined(__APPLE__)
                 socktype & ~(SOCK_NONBLOCK|SOCK_CLOEXEC),
 #else
                 socktype,
 #endif
                 protocol ? (int)ucv_int64_get(protocol) : 0);
 
         if (sockfd == -1)
                 err_return(errno, "socket()");
 
 #if defined(__APPLE__)
         if (socktype & SOCK_NONBLOCK) {
                 int flags = fcntl(sockfd, F_GETFL);
 
                 if (flags == -1) {
                         close(sockfd);
                         err_return(errno, "fcntl(F_GETFL)");
                 }
 
                 if (fcntl(sockfd, F_SETFL, flags | O_NONBLOCK) == -1) {
                         close(sockfd);
                         err_return(errno, "fcntl(F_SETFL)");
                 }
         }
 
         if (socktype & SOCK_CLOEXEC) {
                 if (fcntl(sockfd, F_SETFD, FD_CLOEXEC) == -1) {
                         close(sockfd);
                         err_return(errno, "fcntl(F_SETFD)");
                 }
         }
 #endif
 
         ok_return(ucv_socket_new(vm, sockfd));
 }
 
 /**
  * Connects the socket to a remote address.
  *
  * Attempts to establish a connection to the specified remote address.
  *
  * Returns `true` if the connection is successfully established.
  * Returns `null` if an error occurred during the connection attempt.
  *
  * @function module:socket.socket#connect
  *
  * @param {string|module:socket.socket.SocketAddress} address
  * The address of the remote endpoint to connect to.
  *
  * @param {number} port
  * The port number of the remote endpoint to connect to.
  *
  * @returns {?boolean}
  */
 static uc_value_t *
 uc_socket_inst_connect(uc_vm_t *vm, size_t nargs)
 {
         struct sockaddr_storage ss;
         uc_value_t *addr;
         int ret, sockfd;
         socklen_t slen;
 
         args_get(vm, nargs, &sockfd,
                 "address", UC_NULL, false, &addr);
 
         if (!uv_to_sockaddr(addr, &ss, &slen))
                 return NULL;
 
         ret = connect(sockfd, (struct sockaddr *)&ss, slen);
 
         if (ret == -1)
                 err_return(errno, "connect()");
 
         ok_return(ucv_boolean_new(true));
 }
 
 /**
  * Sends data through the socket.
  *
  * Sends the provided data through the socket handle to the specified remote
  * address, if provided.
  *
  * Returns the number of bytes sent.
  * Returns `null` if an error occurred during the send operation.
  *
  * @function module:socket.socket#send
  *
  * @param {*} data
  * The data to be sent through the socket. String data is sent as-is, any other
  * type is implicitly converted to a string first before being sent on the
  * socket.
  *
  * @param {number} [flags]
  * Optional flags that modify the behavior of the send operation.
  *
  * @param {module:socket.socket.SocketAddress|number[]|string} [address]
  * The address of the remote endpoint to send the data to. It can be either an
  * IP address string, an array returned by {@link module:core#iptoarr|iptoarr()},
  * or an object representing a network address. If not provided, the data is
  * sent to the remote endpoint the socket is connected to.
  *
  * @returns {?number}
  *
  * @see {@link module:socket#sockaddr|sockaddr()}
  *
  * @example
  * // Send to connected socket
  * let tcp_sock = socket.create(socket.AF_INET, socket.SOCK_STREAM);
  * tcp_sock.connect("192.168.1.1", 80);
  * tcp_sock.send("GET / HTTP/1.0\r\n\r\n");
  *
  * // Send a datagram on unconnected socket
  * let udp_sock = socket.create(socket.AF_INET, socket.SOCK_DGRAM);
  * udp_sock.send("Hello there!", 0, "255.255.255.255:9000");
  * udp_sock.send("Hello there!", 0, {
  *   family: socket.AF_INET,      // optional
  *   address: "255.255.255.255",
  *   port: 9000
  * });
  */
 static uc_value_t *
 uc_socket_inst_send(uc_vm_t *vm, size_t nargs)
 {
         uc_value_t *data, *flags, *addr;
         struct sockaddr_storage ss = { 0 };
         struct sockaddr *sa = NULL;
         socklen_t salen = 0;
         char *buf = NULL;
         ssize_t ret;
         int sockfd;
 
         args_get(vm, nargs, &sockfd,
                 "data", UC_NULL, false, &data,
                 "flags", UC_INTEGER, true, &flags,
                 "address", UC_NULL, true, &addr);
 
         if (addr) {
                 if (!uv_to_sockaddr(addr, &ss, &salen))
                         return NULL;
 
                 sa = (struct sockaddr *)&ss;
         }
 
         if (ucv_type(data) != UC_STRING)
                 buf = ucv_to_string(vm, data);
 
         ret = sendto(sockfd,
                 buf ? buf : ucv_string_get(data),
                 buf ? strlen(buf) : ucv_string_length(data),
                 (flags ? ucv_int64_get(flags) : 0) | MSG_NOSIGNAL, sa, salen);
 
         free(buf);
 
         if (ret == -1)
                 err_return(errno, "send()");
 
         ok_return(ucv_int64_new(ret));
 }
 
 /**
  * Receives data from the socket.
  *
  * Receives data from the socket handle, optionally specifying the maximum
  * length of data to receive, flags to modify the receive behavior, and an
  * optional address dictionary where the function will place the address from
  * which the data was received (for unconnected sockets).
  *
  * Returns a string containing the received data.
  * Returns an empty string if the remote side closed the socket.
  * Returns `null` if an error occurred during the receive operation.
  *
  * @function module:socket.socket#recv
  *
  * @param {number} [length=4096]
  * The maximum number of bytes to receive.
  *
  * @param {number} [flags]
  * Optional flags that modify the behavior of the receive operation.
  *
  * @param {Object} [address]
  * An object where the function will store the address from which the data was
  * received. If provided, it will be filled with the details obtained from the
  * sockaddr argument of the underlying `recvfrom()` syscall. See the type
  * definition of {@link module:socket.socket.SocketAddress|SocketAddress} for
  * details on the format.
  *
  * @returns {?string}
  */
 static uc_value_t *
 uc_socket_inst_recv(uc_vm_t *vm, size_t nargs)
 {
         uc_value_t *length, *flags, *addrobj;
         struct sockaddr_storage ss = { 0 };
         uc_stringbuf_t *buf;
         ssize_t len, ret;
         socklen_t sslen;
         int sockfd;
 
         args_get(vm, nargs, &sockfd,
                 "length", UC_INTEGER, true, &length,
                 "flags", UC_INTEGER, true, &flags,
                 "address", UC_OBJECT, true, &addrobj);
 
         len = length ? ucv_to_integer(length) : 4096;
 
         if (errno || len <= 0)
                 err_return(errno, "Invalid length argument");
 
         buf = strbuf_alloc(len);
 
         if (!buf)
                 return NULL;
 
         do {
                 sslen = sizeof(ss);
                 ret = recvfrom(sockfd, strbuf_data(buf), len,
                         flags ? ucv_int64_get(flags) : 0, (struct sockaddr *)&ss, &sslen);
         } while (ret == -1 && errno == EINTR);
 
         if (ret == -1) {
                 strbuf_free(buf);
                 err_return(errno, "recv()");
         }
 
         if (addrobj)
                 sockaddr_to_uv(&ss, addrobj);
 
         ok_return(strbuf_finish(&buf, ret));
 }
 
 uc_declare_vector(strbuf_array_t, uc_stringbuf_t *);
 
 #if defined(__linux__)
 static void optmem_max(size_t *sz) {
         char buf[sizeof("18446744073709551615")] = { 0 };
         int fd, rv;
 
         fd = open("/proc/sys/net/core/optmem_max", O_RDONLY);
 
         if (fd >= 0) {
                 if (read(fd, buf, sizeof(buf) - 1) > 0) {
                         rv = strtol(buf, NULL, 10);
 
                         if (rv > 0 && (size_t)rv < *sz)
                                 *sz = rv;
                 }
 
                 if (fd > 2)
                         close(fd);
         }
 }
 #else
 # define optmem_max(x)
 #endif
 
 
 /**
  * Represents a single control (ancillary data) message returned
  * in the *ancillary* array by {@link module:socket.socket#recvmsg|`recvmsg()`}.
  *
  * @typedef {Object} module:socket.socket.ControlMessage
  * @property {number} level
  * The message socket level (`cmsg_level`), e.g. `SOL_SOCKET`.
  *
  * @property {number} type
  * The protocol specific message type (`cmsg_type`), e.g. `SCM_RIGHTS`.
  *
  * @property {*} data
  * The payload of the control message. If the control message type is known by
  * the socket module, it is represented as a mixed value (array, object, number,
  * etc.) with structure specific to the control message type. If the control
  * message cannot be decoded, *data* is set to a string value containing the raw
  * payload.
  */
 static uc_value_t *
 decode_cmsg(uc_vm_t *vm, struct cmsghdr *cmsg)
 {
         char *s = (char *)CMSG_DATA(cmsg);
         size_t sz = cmsg->cmsg_len - sizeof(*cmsg);
         struct sockaddr_storage *ss;
         uc_value_t *fdarr;
         struct stat st;
         int *fds;
 
         for (size_t i = 0; i < ARRAY_SIZE(cmsgtypes); i++) {
 
                 if (cmsgtypes[i].level != cmsg->cmsg_level)
                         continue;
 
                 if (cmsgtypes[i].type != cmsg->cmsg_type)
                         continue;
 
                 switch ((uintptr_t)cmsgtypes[i].ctype) {
                 case (uintptr_t)CV_INT:
                         return ucv_int64_new(parse_integer(s, sz));
 
                 case (uintptr_t)CV_UINT:
                 case (uintptr_t)CV_BE32:
                         return ucv_uint64_new(parse_unsigned(s, sz));
 
                 case (uintptr_t)CV_SOCKADDR:
                         ss = (struct sockaddr_storage *)s;
 
                         if ((sz >= sizeof(struct sockaddr_in) &&
                              ss->ss_family == AF_INET) ||
                             (sz >= sizeof(struct sockaddr_in6) &&
                              ss->ss_family == AF_INET6))
                         {
                                 uc_value_t *addr = ucv_object_new(vm);
 
                                 if (sockaddr_to_uv(ss, addr))
                                         return addr;
 
                                 ucv_put(addr);
                         }
 
                         return NULL;
 
                 case (uintptr_t)CV_FDS:
                         fdarr = ucv_array_new_length(vm, sz / sizeof(int));
                         fds = (int *)s;
 
                         for (size_t i = 0; i < sz / sizeof(int); i++) {
                                 if (fstat(fds[i], &st) == 0) {
                                         uc_resource_type_t *t;
 
                                         if (S_ISSOCK(st.st_mode)) {
                                                 t = ucv_resource_type_lookup(vm, "socket");
 
                                                 ucv_array_push(fdarr,
                                                         ucv_resource_new(t, (void *)(intptr_t)fds[i]));
 
                                                 continue;
                                         }
                                         else if (S_ISDIR(st.st_mode)) {
                                                 t = ucv_resource_type_lookup(vm, "fs.dir");
 
                                                 if (t) {
                                                         DIR *d = fdopendir(fds[i]);
 
                                                         if (d) {
                                                                 ucv_array_push(fdarr, ucv_resource_new(t, d));
                                                                 continue;
                                                         }
                                                 }
                                         }
                                         else {
                                                 t = ucv_resource_type_lookup(vm, "fs.file");
 
                                                 if (t) {
                                                         int n = fcntl(fds[i], F_GETFL);
                                                         const char *mode;
 
                                                         if (n <= 0 || (n & O_ACCMODE) == O_RDONLY)
                                                                 mode = "r";
                                                         else if ((n & O_ACCMODE) == O_WRONLY)
                                                                 mode = (n & O_APPEND) ? "a" : "w";
                                                         else
                                                                 mode = (n & O_APPEND) ? "a+" : "w+";
 
                                                         FILE *f = fdopen(fds[i], mode);
 
                                                         if (f) {
                                                                 ucv_array_push(fdarr, uc_resource_new(t, f));
                                                                 continue;
                                                         }
                                                 }
                                         }
                                 }
 
                                 ucv_array_push(fdarr, ucv_int64_new(fds[i]));
                         }
 
                         return fdarr;
 
                 case (uintptr_t)CV_STRING:
                         break;
 
                 default:
                         if (sz >= cmsgtypes[i].ctype->size)
                                 return struct_to_uv(s, cmsgtypes[i].ctype);
                 }
 
                 break;
         }
 
         return ucv_string_new_length(s, sz);
 }
 
 static size_t
 estimate_cmsg_size(uc_value_t *uv)
 {
         int cmsg_level = ucv_to_integer(ucv_object_get(uv, "level", NULL));
         int cmsg_type = ucv_to_integer(ucv_object_get(uv, "type", NULL));
         uc_value_t *val = ucv_object_get(uv, "data", NULL);
 
         for (size_t i = 0; i < ARRAY_SIZE(cmsgtypes); i++) {
                 if (cmsgtypes[i].level != cmsg_level)
                         continue;
 
                 if (cmsgtypes[i].type != cmsg_type)
                         continue;
 
                 switch ((uintptr_t)cmsgtypes[i].ctype) {
                 case (uintptr_t)CV_INT:      return sizeof(int);
                 case (uintptr_t)CV_UINT:     return sizeof(unsigned int);
                 case (uintptr_t)CV_BE32:     return sizeof(uint32_t);
                 case (uintptr_t)CV_SOCKADDR: return sizeof(struct sockaddr_storage);
                 case (uintptr_t)CV_FDS:      return ucv_array_length(val) * sizeof(int);
                 case (uintptr_t)CV_STRING:   return ucv_string_length(val);
                 default:                     return cmsgtypes[i].ctype->size;
                 }
         }
 
         switch (ucv_type(val)) {
                 case UC_BOOLEAN: return sizeof(unsigned int);
                 case UC_INTEGER: return sizeof(int);
                 case UC_STRING:  return ucv_string_length(val);
                 default:         return 0;
         }
 }
 
 static bool
 encode_cmsg(uc_vm_t *vm, uc_value_t *uv, struct cmsghdr *cmsg)
 {
         struct { int *entries; size_t count; } fds = { 0 };
         void *dataptr = NULL;
         socklen_t datasz = 0;
         char *st = NULL;
         size_t i;
         union {
                 int i;
                 unsigned int u;
                 uint32_t u32;
                 struct sockaddr_storage ss;
         } val;
 
         cmsg->cmsg_level = ucv_to_integer(ucv_object_get(uv, "level", NULL));
         cmsg->cmsg_type = ucv_to_integer(ucv_object_get(uv, "type", NULL));
 
         uc_value_t *data = ucv_object_get(uv, "data", NULL);
 
         for (i = 0; i < ARRAY_SIZE(cmsgtypes); i++) {
                 if (cmsgtypes[i].level != cmsg->cmsg_level)
                         continue;
 
                 if (cmsgtypes[i].type != cmsg->cmsg_type)
                         continue;
 
                 switch ((uintptr_t)cmsgtypes[i].ctype) {
                 case (uintptr_t)CV_INT:
                         val.i = ucv_to_integer(data);
                         datasz = sizeof(val.i);
                         dataptr = &val;
                         break;
 
                 case (uintptr_t)CV_UINT:
                         val.u = ucv_to_unsigned(data);
                         datasz = sizeof(val.u);
                         dataptr = &val;
                         break;
 
                 case (uintptr_t)CV_BE32:
                         val.u32 = ucv_to_unsigned(data);
                         datasz = sizeof(val.u32);
                         dataptr = &val;
                         break;
 
                 case (uintptr_t)CV_SOCKADDR:
                         if (uv_to_sockaddr(data, &val.ss, &datasz))
                                 dataptr = &val;
                         else
                                 datasz = 0, dataptr = NULL;
                         break;
 
                 case (uintptr_t)CV_FDS:
                         if (ucv_type(data) == UC_ARRAY) {
                                 for (size_t i = 0; i < ucv_array_length(data); i++) {
                                         int fd;
 
                                         if (uv_to_fileno(vm, ucv_array_get(data, i), &fd))
                                                 uc_vector_push(&fds, fd);
                                 }
                         }
 
                         datasz = sizeof(fds.entries[0]) * fds.count;
                         dataptr = fds.entries;
                         break;
 
                 case (uintptr_t)CV_STRING:
                         datasz = ucv_string_length(data);
                         dataptr = ucv_string_get(data);
                         break;
 
                 default:
                         st = uv_to_struct(data, cmsgtypes[i].ctype);
                         datasz = st ? cmsgtypes[i].ctype->size : 0;
                         dataptr = st;
                         break;
                 }
 
                 break;
         }
 
         /* we don't know this kind of control message, guess encoding */
         if (i == ARRAY_SIZE(cmsgtypes)) {
                 switch (ucv_type(data)) {
                 /* treat boolean as int with values 1 or 0 */
                 case UC_BOOLEAN:
                         val.u = ucv_boolean_get(data);
                         dataptr = &val;
                         datasz = sizeof(val.u);
                         break;
 
                 /* treat integers as int */
                 case UC_INTEGER:
                         if (ucv_is_u64(data)) {
                                 val.u = ucv_uint64_get(data);
                                 datasz = sizeof(val.u);
                         }
                         else {
                                 val.i = ucv_int64_get(data);
                                 datasz = sizeof(val.i);
                         }
 
                         dataptr = &val;
                         break;
 
                 /* pass strings as-is */
                 case UC_STRING:
                         dataptr = ucv_string_get(data);
                         datasz = ucv_string_length(data);
                         break;
 
                 default:
                         break;
                 }
         }
 
         cmsg->cmsg_len = CMSG_LEN(datasz);
 
         if (dataptr)
                 memcpy(CMSG_DATA(cmsg), dataptr, datasz);
 
         uc_vector_clear(&fds);
         free(st);
 
         return true;
 }
 
 /**
  * Sends a message through the socket.
  *
  * Sends a message through the socket handle, supporting complex message
  * structures including multiple data buffers and ancillary data. This function
  * allows for precise control over the message content and delivery behavior.
  *
  * Returns the number of sent bytes.
  *
  * Returns `null` if an error occurred.
  *
  * @function module:socket.socket#sendmsg
  *
  * @param {*} [data]
  * The data to be sent. If a string is provided, it is sent as is. If an array
  * is specified, each item is sent as a separate `struct iovec`. Non-string
  * values are implicitly converted to a string and sent. If omitted, only
  * ancillary data and address are considered.
  *
  * @param {module:socket.socket.ControlMessage[]|string} [ancillaryData]
  * Optional ancillary data to be sent. If an array is provided, each element is
  * converted to a control message. If a string is provided, it is sent as-is
  * without further interpretation. Refer to
  * {@link module:socket.socket#recvmsg|`recvmsg()`} and
  * {@link module:socket.socket.ControlMessage|ControlMessage} for details.
  *
  * @param {module:socket.socket.SocketAddress} [address]
  * The destination address for the message. If provided, it sets or overrides
  * the packet destination address.
  *
  * @param {number} [flags]
  * Optional flags to modify the behavior of the send operation. This should be a
  * bitwise OR-ed combination of `MSG_*` flag values.
  *
  * @returns {?number}
  * Returns the number of bytes sent on success, or `null` if an error occurred.
  *
  * @example
  * // Send file descriptors over domain socket
  * const f1 = fs.open("example.txt", "w");
  * const f2 = fs.popen("date +%s", "r");
  * const sk = socket.connect({ family: socket.AF_UNIX, path: "/tmp/socket" });
 
  * sk.sendmsg("Hi there, here's some descriptors!", [
  *      { level: socket.SOL_SOCKET, type: socket.SCM_RIGHTS, data: [ f1, f2 ] }
  * ]);
  *
  * // Send multiple values in one datagram
  * sk.sendmsg([ "This", "is", "one", "message" ]);
  */
 static uc_value_t *
 uc_socket_inst_sendmsg(uc_vm_t *vm, size_t nargs)
 {
         uc_value_t *data, *ancdata, *addr, *flags;
         struct sockaddr_storage ss = { 0 };
         strbuf_array_t sbarr = { 0 };
         struct msghdr msg = { 0 };
         struct iovec vec = { 0 };
         int flagval, sockfd;
         socklen_t slen;
         ssize_t ret;
 
         args_get(vm, nargs, &sockfd,
                 "data", UC_NULL, true, &data,
                 "ancillary data", UC_NULL, true, &ancdata,
                 "address", UC_OBJECT, true, &addr,
                 "flags", UC_INTEGER, true, &flags);
 
         flagval = flags ? ucv_int64_get(flags) : 0;
 
         /* treat string ancdata arguemnt as raw controldata buffer */
         if (ucv_type(ancdata) == UC_STRING) {
                 msg.msg_control = ucv_string_get(ancdata);
                 msg.msg_controllen = ucv_string_length(ancdata);
         }
         /* encode ancdata passed as array */
         else if (ucv_type(ancdata) == UC_ARRAY) {
                 msg.msg_controllen = 0;
 
                 for (size_t i = 0; i < ucv_array_length(ancdata); i++) {
                         size_t sz = estimate_cmsg_size(ucv_array_get(ancdata, i));
 
                         if (sz > 0)
                                 msg.msg_controllen += CMSG_SPACE(sz);
                 }
 
                 if (msg.msg_controllen > 0) {
                         msg.msg_control = xalloc(msg.msg_controllen);
 
                         struct cmsghdr *cmsg = NULL;
 
                         for (size_t i = 0; i < ucv_array_length(ancdata); i++) {
 #ifdef __clang_analyzer__
                                 /* Clang static analyzer assumes that CMSG_*HDR() returns
                                  * allocated heap pointers and not pointers into the
                                  * msg.msg_control buffer. Nudge it. */
                                 cmsg = (struct cmsghdr *)msg.msg_control;
 #else
                                 cmsg = cmsg ? CMSG_NXTHDR(&msg, cmsg) : CMSG_FIRSTHDR(&msg);
 #endif
 
                                 if (!cmsg) {
                                         free(msg.msg_control);
                                         err_return(ENOBUFS, "Not enough CMSG buffer space");
                                 }
 
                                 if (!encode_cmsg(vm, ucv_array_get(ancdata, i), cmsg)) {
                                         free(msg.msg_control);
                                         return NULL;
                                 }
                         }
 
                         msg.msg_controllen = (cmsg != NULL)
                                 ? (char *)cmsg - (char *)msg.msg_control + CMSG_SPACE(cmsg->cmsg_len)
                                 : 0;
                 }
         }
         else if (ancdata) {
                 err_return(EINVAL, "Ancillary data must be string or array value");
         }
 
         /* prepare iov array */
         if (ucv_type(data) == UC_ARRAY) {
                 msg.msg_iovlen = ucv_array_length(data);
                 msg.msg_iov = (msg.msg_iovlen > 1)
                         ? xalloc(sizeof(vec) * msg.msg_iovlen) : &vec;
 
                 for (size_t i = 0; i < (size_t)msg.msg_iovlen; i++) {
                         uc_value_t *item = ucv_array_get(data, i);
 
                         if (ucv_type(item) == UC_STRING) {
                                 msg.msg_iov[i].iov_base = _ucv_string_get(&((uc_array_t *)data)->entries[i]);
                                 msg.msg_iov[i].iov_len = ucv_string_length(item);
                         }
                         else if (item) {
                                 struct printbuf *pb = xprintbuf_new();
                                 uc_vector_push(&sbarr, pb);
                                 ucv_to_stringbuf(vm, pb, item, false);
                                 msg.msg_iov[i].iov_base = pb->buf;
                                 msg.msg_iov[i].iov_len = pb->bpos;
                         }
                 }
         }
         else if (ucv_type(data) == UC_STRING) {
                 msg.msg_iovlen = 1;
                 msg.msg_iov = &vec;
                 vec.iov_base = ucv_string_get(data);
                 vec.iov_len = ucv_string_length(data);
         }
         else if (data) {
                 struct printbuf *pb = xprintbuf_new();
                 uc_vector_push(&sbarr, pb);
                 ucv_to_stringbuf(vm, pb, data, false);
                 msg.msg_iovlen = 1;
                 msg.msg_iov = &vec;
                 vec.iov_base = pb->buf;
                 vec.iov_len = pb->bpos;
         }
 
         /* prepare address */
         if (addr && uv_to_sockaddr(addr, &ss, &slen)) {
                 msg.msg_name = &ss;
                 msg.msg_namelen = slen;
         }
 
         /* now send actual data */
         do {
                 ret = sendmsg(sockfd, &msg, flagval);
         } while (ret == -1 && errno == EINTR);
 
         while (sbarr.count > 0)
                 printbuf_free(sbarr.entries[--sbarr.count]);
 
         uc_vector_clear(&sbarr);
 
         if (msg.msg_iov != &vec)
                 free(msg.msg_iov);
 
         free(msg.msg_control);
 
         if (ret == -1)
                 err_return(errno, "sendmsg()");
 
         ok_return(ucv_int64_new(ret));
 }
 
 
 
 /**
  * Represents a message object returned by
  * {@link module:socket.socket#recvmsg|`recvmsg()`}.
  *
  * @typedef {Object} module:socket.socket.ReceivedMessage
  * @property {number} flags
  * Integer value containing bitwise OR-ed `MSG_*` result flags returned by the
  * underlying receive call.
  *
  * @property {number} length
  * Integer value containing the number of bytes returned by the `recvmsg()`
  * syscall, which might be larger than the received data in case `MSG_TRUNC`
  * was passed.
  *
  * @property {module:socket.socket.SocketAddress} address
  * The address from which the message was received.
  *
  * @property {string[]|string} data
  * An array of strings, each representing the received message data.
  * Each string corresponds to one buffer size specified in the *sizes* argument.
  * If a single receive size was passed instead of an array of sizes, *data* will
  * hold a string containing the received data.
  *
  * @property {module:socket.socket.ControlMessage[]} [ancillary]
  * An array of received control messages. Only included if a non-zero positive
  * *ancillarySize* was passed to `recvmsg()`.
  */
 
 /**
  * Receives a message from the socket.
  *
  * Receives a message from the socket handle, allowing for more complex data
  * reception compared to `recv()`. This includes the ability to receive
  * ancillary data (such as file descriptors, credentials, etc.), multiple
  * message segments, and optional flags to modify the receive behavior.
  *
  * Returns an object containing the received message data, ancillary data,
  * and the sender's address.
  *
  * Returns `null` if an error occurred during the receive operation.
  *
  * @function module:socket.socket#recvmsg
  *
  * @param {number[]|number} [sizes]
  * Specifies the sizes of the buffers used for receiving the message. If an
  * array of numbers is provided, each number determines the size of an
  * individual buffer segment, creating multiple `struct iovec` for reception.
  * If a single number is provided, a single buffer of that size is used.
  *
  * @param {number} [ancillarySize]
  * The size allocated for the ancillary data buffer. If not provided, ancillary
  * data is not processed.
  *
  * @param {number} [flags]
  * Optional flags to modify the behavior of the receive operation. This should
  * be a bitwise OR-ed combination of flag values.
  *
  * @returns {?module:socket.socket.ReceivedMessage}
  * An object containing the received message data, ancillary data,
  * and the sender's address.
  *
  * @example
  * // Receive file descriptors over domain socket
  * const sk = socket.listen({ family: socket.AF_UNIX, path: "/tmp/socket" });
  * sk.setopt(socket.SOL_SOCKET, socket.SO_PASSCRED, true);
  *
  * const msg = sk.recvmsg(1024, 1024); *
  * for (let cmsg in msg.ancillary)
  *   if (cmsg.level == socket.SOL_SOCKET && cmsg.type == socket.SCM_RIGHTS)
  *     print(`Got some descriptors: ${cmsg.data}!\n`);
  *
  * // Receive message in segments of 10, 128 and 512 bytes
  * const msg = sk.recvmsg([ 10, 128, 512 ]);
  * print(`Message parts: ${msg.data[0]}, ${msg.data[1]}, ${msg.data[2]}\n`);
  *
  * // Peek buffer
  * const msg = sk.recvmsg(0, 0, socket.MSG_PEEK|socket.MSG_TRUNC);
  * print(`Received ${length(msg.data)} bytes, ${msg.length} bytes available\n`);
  */
 static uc_value_t *
 uc_socket_inst_recvmsg(uc_vm_t *vm, size_t nargs)
 {
         uc_value_t *length, *anclength, *flags, *rv;
         struct sockaddr_storage ss = { 0 };
         strbuf_array_t sbarr = { 0 };
         struct msghdr msg = { 0 };
         struct iovec vec = { 0 };
         int flagval, sockfd;
         ssize_t ret;
 
         args_get(vm, nargs, &sockfd,
                 "length", UC_NULL, true, &length,
                 "ancillary length", UC_INTEGER, true, &anclength,
                 "flags", UC_INTEGER, true, &flags);
 
         flagval = flags ? ucv_int64_get(flags) : 0;
 
 #if defined(__linux__)
         flagval |= MSG_CMSG_CLOEXEC;
 #endif
 
         /* prepare ancillary data buffer */
         if (anclength) {
                 size_t sz = ucv_to_unsigned(anclength);
 
                 if (errno != 0)
                         err_return(errno, "Invalid ancillary data length");
 
                 optmem_max(&sz);
 
                 if (sz > 0) {
                         msg.msg_controllen = sz;
                         msg.msg_control = xalloc(sz);
                 }
         }
 
         /* prepare iov array */
         if (ucv_type(length) == UC_ARRAY) {
                 msg.msg_iovlen = ucv_array_length(length);
                 msg.msg_iov = (msg.msg_iovlen > 1)
                         ? xalloc(sizeof(vec) * msg.msg_iovlen) : &vec;
 
                 for (size_t i = 0; i < (size_t)msg.msg_iovlen; i++) {
                         size_t sz = ucv_to_unsigned(ucv_array_get(length, i));
 
                         if (errno != 0) {
                                 while (sbarr.count > 0)
                                         strbuf_free(sbarr.entries[--sbarr.count]);
 
                                 uc_vector_clear(&sbarr);
 
                                 if (msg.msg_iov != &vec)
                                         free(msg.msg_iov);
 
                                 free(msg.msg_control);
 
                                 err_return(errno, "Invalid length value");
                         }
 
                         uc_vector_push(&sbarr, strbuf_alloc(sz));
                         msg.msg_iov[i].iov_base = strbuf_data(sbarr.entries[i]);
                         msg.msg_iov[i].iov_len = sz;
                 }
         }
         else {
                 size_t sz = ucv_to_unsigned(length);
 
                 if (errno != 0) {
                         free(msg.msg_control);
                         err_return(errno, "Invalid length value");
                 }
 
                 uc_vector_push(&sbarr, strbuf_alloc(sz));
 
                 msg.msg_iovlen = 1;
                 msg.msg_iov = &vec;
                 vec.iov_base = strbuf_data(sbarr.entries[0]);
                 vec.iov_len = sz;
         }
 
         /* now receive actual data */
         msg.msg_name = &ss;
         msg.msg_namelen = sizeof(ss);
 
         do {
                 ret = recvmsg(sockfd, &msg, flagval);
         } while (ret == -1 && errno == EINTR);
 
         if (ret == -1) {
                 while (sbarr.count > 0)
                         strbuf_free(sbarr.entries[--sbarr.count]);
 
                 uc_vector_clear(&sbarr);
 
                 if (msg.msg_iov != &vec)
                         free(msg.msg_iov);
 
                 free(msg.msg_control);
 
                 err_return(errno, "recvmsg()");
         }
 
         rv = ucv_object_new(vm);
 
         ucv_object_add(rv, "flags", ucv_int64_new(msg.msg_flags));
         ucv_object_add(rv, "length", ucv_int64_new(ret));
 
         if (msg.msg_namelen > 0) {
                 uc_value_t *addr = ucv_object_new(vm);
 
                 if (sockaddr_to_uv(&ss, addr))
                         ucv_object_add(rv, "address", addr);
                 else
                         ucv_put(addr);
         }
 
         if (msg.msg_controllen > 0) {
                 uc_value_t *ancillary = ucv_array_new(vm);
 
                 for (struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
                      cmsg != NULL;
                      cmsg = CMSG_NXTHDR(&msg, cmsg))
                 {
                         uc_value_t *c = ucv_object_new(vm);
 
                         ucv_object_add(c, "level", ucv_int64_new(cmsg->cmsg_level));
                         ucv_object_add(c, "type", ucv_int64_new(cmsg->cmsg_type));
                         ucv_object_add(c, "data", decode_cmsg(vm, cmsg));
 
                         ucv_array_push(ancillary, c);
                 }
 
                 ucv_object_add(rv, "ancillary", ancillary);
         }
 
         if (ret >= 0) {
                 if (ucv_type(length) == UC_ARRAY) {
                         uc_value_t *data = ucv_array_new_length(vm, msg.msg_iovlen);
 
                         for (size_t i = 0; i < (size_t)msg.msg_iovlen; i++) {
                                 size_t sz = ret;
 
                                 if (sz > msg.msg_iov[i].iov_len)
                                         sz = msg.msg_iov[i].iov_len;
 
                                 ucv_array_push(data, strbuf_finish(&sbarr.entries[i], sz));
                                 ret -= sz;
                         }
 
                         ucv_object_add(rv, "data", data);
                 }
                 else {
                         size_t sz = ret;
 
                         if (sz > msg.msg_iov[0].iov_len)
                                 sz = msg.msg_iov[0].iov_len;
 
                         ucv_object_add(rv, "data", strbuf_finish(&sbarr.entries[0], sz));
                 }
         }
 
         uc_vector_clear(&sbarr);
 
         if (msg.msg_iov != &vec)
                 free(msg.msg_iov);
 
         free(msg.msg_control);
 
         ok_return(rv);
 }
 
 /**
  * Binds a socket to a specific address.
  *
  * This function binds the socket to the specified address.
  *
  * Returns `true` if the socket is successfully bound.
  *
  * Returns `null` on error, e.g. when the address is in use.
  *
  * @function module:socket.socket#bind
  *
  * @param {string|module:socket.socket.SocketAddress} address
  * The IP address to bind the socket to.
  *
  * @returns {?boolean}
  *
  * @example
  * const sock = socket.create(…);
  * const success = sock.bind("192.168.0.1:80");
  *
  * if (success)
  *     print(`Socket bound successfully!\n`);
  * else
  *     print(`Failed to bind socket: ${sock.error()}.\n`);
  */
 static uc_value_t *
 uc_socket_inst_bind(uc_vm_t *vm, size_t nargs)
 {
         struct sockaddr_storage ss = { 0 };
         uc_value_t *addr;
         socklen_t slen;
         int sockfd;
 
         args_get(vm, nargs, &sockfd,
                 "address", UC_NULL, true, &addr);
 
         if (addr) {
                 if (!uv_to_sockaddr(addr, &ss, &slen))
                         return NULL;
 
                 if (bind(sockfd, (struct sockaddr *)&ss, slen) == -1)
                         err_return(errno, "bind()");
         }
         else {
 #if defined(__linux__)
                 int sval = 0;
                 slen = sizeof(sval);
 
                 if (getsockopt(sockfd, SOL_SOCKET, SO_DOMAIN, &sval, &slen) == -1)
                         err_return(errno, "getsockopt()");
 
                 switch (sval) {
                 case AF_INET6:
                         ss.ss_family = AF_INET6;
                         slen = sizeof(struct sockaddr_in6);
                         break;
 
                 case AF_INET:
                         ss.ss_family = AF_INET;
                         slen = sizeof(struct sockaddr_in);
                         break;
 
                 default:
                         err_return(EAFNOSUPPORT, "Unsupported socket address family");
                 }
 
                 if (bind(sockfd, (struct sockaddr *)&ss, slen) == -1)
                         err_return(errno, "bind()");
 #else
                 ss.ss_family = AF_INET6;
                 slen = sizeof(struct sockaddr_in6);
 
                 if (bind(sockfd, (struct sockaddr *)&ss, slen) == -1) {
                         if (errno != EAFNOSUPPORT)
                                 err_return(errno, "bind()");
 
                         ss.ss_family = AF_INET;
                         slen = sizeof(struct sockaddr_in);
 
                         if (bind(sockfd, (struct sockaddr *)&ss, slen) == -1)
                                 err_return(errno, "bind()");
                 }
 #endif
         }
 
         ok_return(ucv_boolean_new(true));
 }
 
 /**
  * Listen for connections on a socket.
  *
  * This function marks the socket as a passive socket, that is, as a socket that
  * will be used to accept incoming connection requests using `accept()`.
  *
  * The `backlog` parameter specifies the maximum length to which the queue of
  * pending connections may grow. If a connection request arrives when the queue
  * is full, the client connection might get refused.
  *
  * If `backlog` is not provided, it defaults to 128.
  *
  * Returns `true` if the socket is successfully marked as passive.
  * Returns `null` if an error occurred, e.g. when the requested port is in use.
  *
  * @function module:socket.socket#listen
  *
  * @param {number} [backlog=128]
  * The maximum length of the queue of pending connections.
  *
  * @returns {?boolean}
  *
  * @see {@link module:socket.socket#accept|accept()}
  *
  * @example
  * const sock = socket.create(…);
  * sock.bind(…);
  *
  * const success = sock.listen(10);
  * if (success)
  *     print(`Socket is listening for incoming connections!\n`);
  * else
  *     print(`Failed to listen on socket: ${sock.error()}\n`);
  */
 static uc_value_t *
 uc_socket_inst_listen(uc_vm_t *vm, size_t nargs)
 {
         uc_value_t *backlog;
         int ret, sockfd;
 
         args_get(vm, nargs, &sockfd,
                 "backlog", UC_INTEGER, true, &backlog);
 
         ret = listen(sockfd, backlog ? ucv_to_unsigned(backlog) : 128);
 
         if (ret == -1)
                 err_return(errno, "listen()");
 
         ok_return(ucv_boolean_new(true));
 }
 
 /**
  * Accept a connection on a socket.
  *
  * This function accepts a connection on the socket. It extracts the first
  * connection request on the queue of pending connections, creates a new
  * connected socket, and returns a new socket handle referring to that socket.
  * The newly created socket is not in listening state and has no backlog.
  *
  * When a optional `address` dictionary is provided, it is populated with the
  * remote address details of the peer socket.
  *
  * The optional `flags` parameter is a bitwise-or-ed number of flags to modify
  * the behavior of accepted peer socket. Possible values are:
  * - `SOCK_CLOEXEC`: Enable close-on-exec semantics for the new socket.
  * - `SOCK_NONBLOCK`: Enable nonblocking mode for the new socket.
  *
  * Returns a socket handle representing the newly created peer socket of the
  * accepted connection.
  *
  * Returns `null` if an error occurred.
  *
  * @function module:socket.socket#accept
  *
  * @param {object} [address]
  * An optional dictionary to receive the address details of the peer socket.
  * See {@link module:socket.socket.SocketAddress|SocketAddress} for details.
  *
  * @param {number} [flags]
  * Optional flags to modify the behavior of the peer socket.
  *
  * @returns {?module:socket.socket}
  *
  * @example
  * const sock = socket.create(…);
  * sock.bind(…);
  * sock.listen();
  *
  * const peerAddress = {};
  * const newSocket = sock.accept(peerAddress, socket.SOCK_CLOEXEC);
  * if (newSocket)
  *     print(`Accepted connection from: ${peerAddress}\n`);
  * else
  *     print(`Failed to accept connection: ${sock.error()}\n`);
  */
 static uc_value_t *
 uc_socket_inst_accept(uc_vm_t *vm, size_t nargs)
 {
         struct sockaddr_storage ss = { 0 };
         int peerfd, sockfd, sockflags;
         uc_value_t *addrobj, *flags;
         socklen_t slen;
 
         args_get(vm, nargs, &sockfd,
                 "address", UC_OBJECT, true, &addrobj,
                 "flags", UC_INTEGER, true, &flags);
 
         slen = sizeof(ss);
         sockflags = flags ? ucv_to_integer(flags) : 0;
 
 #ifdef __APPLE__
         peerfd = accept(sockfd, (struct sockaddr *)&ss, &slen);
 
         if (peerfd == -1)
                 err_return(errno, "accept()");
 
         if (sockflags & SOCK_CLOEXEC) {
                 if (fcntl(peerfd, F_SETFD, FD_CLOEXEC) == -1) {
                         close(peerfd);
                         err_return(errno, "fcntl(F_SETFD)");
                 }
         }
 
         if (sockflags & SOCK_NONBLOCK) {
                 sockflags = fcntl(peerfd, F_GETFL);
 
                 if (sockflags == -1) {
                         close(peerfd);
                         err_return(errno, "fcntl(F_GETFL)");
                 }
 
                 if (fcntl(peerfd, F_SETFL, sockflags | O_NONBLOCK) == -1) {
                         close(peerfd);
                         err_return(errno, "fcntl(F_SETFL)");
                 }
         }
 #else
         peerfd = accept4(sockfd, (struct sockaddr *)&ss, &slen, sockflags);
 
         if (peerfd == -1)
                 err_return(errno, "accept4()");
 #endif
 
         if (addrobj)
                 sockaddr_to_uv(&ss, addrobj);
 
         ok_return(ucv_socket_new(vm, peerfd));
 }
 
 /**
  * Shutdown part of a full-duplex connection.
  *
  * This function shuts down part of the full-duplex connection associated with
  * the socket handle. The `how` parameter specifies which half of the connection
  * to shut down. It can take one of the following constant values:
  *
  * - `SHUT_RD`: Disables further receive operations.
  * - `SHUT_WR`: Disables further send operations.
  * - `SHUT_RDWR`: Disables further send and receive operations.
  *
  * Returns `true` if the shutdown operation is successful.
  * Returns `null` if an error occurred.
  *
  * @function module:socket.socket#shutdown
  *
  * @param {number} how
  * Specifies which half of the connection to shut down.
  * It can be one of the following constant values: `SHUT_RD`, `SHUT_WR`,
  * or `SHUT_RDWR`.
  *
  * @returns {?boolean}
  *
  * @example
  * const sock = socket.create(…);
  * sock.connect(…);
  * // Perform data exchange…
  *
  * const success = sock.shutdown(socket.SHUT_WR);
  * if (success)
  *     print(`Send operations on socket shut down successfully.\n`);
  * else
  *     print(`Failed to shut down send operations: ${sock.error()}\n`);
  */
 static uc_value_t *
 uc_socket_inst_shutdown(uc_vm_t *vm, size_t nargs)
 {
         uc_value_t *how;
         int sockfd, ret;
 
         args_get(vm, nargs, &sockfd,
                 "how", UC_INTEGER, true, &how);
 
         ret = shutdown(sockfd, ucv_int64_get(how));
 
         if (ret == -1)
                 err_return(errno, "shutdown()");
 
         ok_return(ucv_boolean_new(true));
 }
 
 /**
  * Represents a credentials information object returned by
  * {@link module:socket.socket#peercred|`peercred()`}.
  *
  * @typedef {Object} module:socket.socket.PeerCredentials
  * @property {number} uid
  * The effective user ID the remote socket endpoint.
  *
  * @property {number} gid
  * The effective group ID the remote socket endpoint.
  *
  * @property {number} pid
  * The ID of the process the remote socket endpoint belongs to.
  */
 
 /**
  * Retrieves the peer credentials.
  *
  * This function retrieves the remote uid, gid and pid of a connected UNIX
  * domain socket.
  *
  * Returns the remote credentials if the operation is successful.
  * Returns `null` on error.
  *
  * @function module:socket.socket#peercred
  *
  * @returns {?module:socket.socket.PeerCredentials}
  *
  * @example
  * const sock = socket.create(socket.AF_UNIX, …);
  * sock.connect(…);
  *
  * const peerCredentials = sock.peercred();
  * if (peerCredentials)
  *     print(`Peer credentials: ${peerCredentials}\n`);
  * else
  *     print(`Failed to retrieve peer credentials: ${sock.error()}\n`);
  */
 static uc_value_t *
 uc_socket_inst_peercred(uc_vm_t *vm, size_t nargs)
 {
         uc_value_t *rv = NULL;
         socklen_t optlen;
         int ret, sockfd;
 
         args_get(vm, nargs, &sockfd);
 
 #if defined(__linux__)
         struct ucred cred;
 
         optlen = sizeof(cred);
         ret = getsockopt(sockfd, SOL_SOCKET, SO_PEERCRED, &cred, &optlen);
 
         if (ret == -1)
                 err_return(errno, "getsockopt()");
 
         if (optlen != sizeof(cred))
                 err_return(EINVAL, "Invalid credentials received");
 
         rv = ucv_object_new(vm);
 
         ucv_object_add(rv, "uid", ucv_uint64_new(cred.uid));
         ucv_object_add(rv, "gid", ucv_uint64_new(cred.gid));
         ucv_object_add(rv, "pid", ucv_int64_new(cred.pid));
 #elif defined(__APPLE__)
         struct xucred cred;
         pid_t pid;
 
         optlen = sizeof(cred);
         ret = getsockopt(sockfd, SOL_LOCAL, LOCAL_PEERCRED, &cred, &optlen);
 
         if (ret == -1)
                 err_return(errno, "getsockopt(LOCAL_PEERCRED)");
 
         if (optlen != sizeof(cred) || cred.cr_version != XUCRED_VERSION)
                 err_return(EINVAL, "Invalid credentials received");
 
         rv = ucv_object_new(vm);
 
         ucv_object_add(rv, "uid", ucv_uint64_new(cred.cr_uid));
         ucv_object_add(rv, "gid", ucv_uint64_new(cred.cr_gid));
 
         optlen = sizeof(pid);
         ret = getsockopt(sockfd, SOL_LOCAL, LOCAL_PEERPID, &pid, &optlen);
 
         if (ret == -1) {
                 ucv_put(rv);
                 err_return(errno, "getsockopt(LOCAL_PEERPID)");
         }
 
         ucv_object_add(rv, "pid", ucv_int64_new(pid));
 #else
         err_return(ENOSYS, "Operation not supported on this system");
 #endif
 
         return rv;
 }
 
 /**
  * Retrieves the remote address.
  *
  * This function retrieves the remote address of a connected socket.
  *
  * Returns the remote address if the operation is successful.
  * Returns `null` on error.
  *
  * @function module:socket.socket#peername
  *
  * @returns {?module:socket.socket.SocketAddress}
  *
  * @see {@link module:socket.socket#sockname|sockname()}
  *
  * @example
  * const sock = socket.create(…);
  * sock.connect(…);
  *
  * const peerAddress = sock.peername();
  * if (peerAddress)
  *     print(`Connected to ${peerAddress}\n`);
  * else
  *     print(`Failed to retrieve peer address: ${sock.error()}\n`);
  */
 static uc_value_t *
 uc_socket_inst_peername(uc_vm_t *vm, size_t nargs)
 {
         struct sockaddr_storage ss = { 0 };
         uc_value_t *addr;
         socklen_t sslen;
         int sockfd, ret;
 
         args_get(vm, nargs, &sockfd);
 
         sslen = sizeof(ss);
         ret = getpeername(sockfd, (struct sockaddr *)&ss, &sslen);
 
         if (ret == -1)
                 err_return(errno, "getpeername()");
 
         addr = ucv_object_new(vm);
         sockaddr_to_uv(&ss, addr);
 
         ok_return(addr);
 }
 
 /**
  * Retrieves the local address.
  *
  * This function retrieves the local address of a bound or connected socket.
  *
  * Returns the local address if the operation is successful.
  * Returns `null` on error.
  *
  * @function module:socket.socket#sockname
  *
  * @returns {?module:socket.socket.SocketAddress}
  *
  * @see {@link module:socket.socket#peername|peername()}
  *
  * @example
  * const sock = socket.create(…);
  * sock.connect(…);
  *
  * const myAddress = sock.sockname();
  * if (myAddress)
  *     print(`My source IP address is ${myAddress}\n`);
  * else
  *     print(`Failed to retrieve peer address: ${sock.error()}\n`);
  */
 static uc_value_t *
 uc_socket_inst_sockname(uc_vm_t *vm, size_t nargs)
 {
         struct sockaddr_storage ss = { 0 };
         uc_value_t *addr;
         socklen_t sslen;
         int sockfd, ret;
 
         args_get(vm, nargs, &sockfd);
 
         sslen = sizeof(ss);
         ret = getsockname(sockfd, (struct sockaddr *)&ss, &sslen);
 
         if (ret == -1)
                 err_return(errno, "getsockname()");
 
         addr = ucv_object_new(vm);
         sockaddr_to_uv(&ss, addr);
 
         ok_return(addr);
 }
 
 /**
  * Closes the socket.
  *
  * This function closes the socket, releasing its resources and terminating its
  * associated connections.
  *
  * Returns `true` if the socket was successfully closed.
  * Returns `null` on error.
  *
  * @function module:socket.socket#close
  *
  * @returns {?boolean}
  *
  * @example
  * const sock = socket.create(…);
  * sock.connect(…);
  * // Perform operations with the socket…
  * sock.close();
  */
 static uc_value_t *
 uc_socket_inst_close(uc_vm_t *vm, size_t nargs)
 {
         int *sockfd = uc_fn_this("socket");
 
         if (!sockfd || *sockfd == -1)
                 err_return(EBADF, "Invalid socket context");
 
         if (!xclose(sockfd))
                 err_return(errno, "close()");
 
         ok_return(ucv_boolean_new(true));
 }
 
 static void
 close_socket(void *ud)
 {
         int fd = (intptr_t)ud;
 
         if (fd != -1)
                 close(fd);
 }
 
 static const uc_function_list_t socket_fns[] = {
         { "connect",    uc_socket_inst_connect },
         { "bind",               uc_socket_inst_bind },
         { "listen",             uc_socket_inst_listen },
         { "accept",             uc_socket_inst_accept },
         { "send",               uc_socket_inst_send },
         { "sendmsg",    uc_socket_inst_sendmsg },
         { "recv",           uc_socket_inst_recv },
         { "recvmsg",    uc_socket_inst_recvmsg },
         { "setopt",             uc_socket_inst_setopt },
         { "getopt",             uc_socket_inst_getopt },
         { "fileno",             uc_socket_inst_fileno },
         { "shutdown",   uc_socket_inst_shutdown },
         { "peercred",   uc_socket_inst_peercred },
         { "peername",   uc_socket_inst_peername },
         { "sockname",   uc_socket_inst_sockname },
         { "close",              uc_socket_inst_close },
         { "error",              uc_socket_error },
 };
 
 static const uc_function_list_t global_fns[] = {
         { "sockaddr",   uc_socket_sockaddr },
         { "create",             uc_socket_create },
         { "nameinfo",   uc_socket_nameinfo },
         { "addrinfo",   uc_socket_addrinfo },
         { "poll",               uc_socket_poll },
         { "connect",    uc_socket_connect },
         { "listen",             uc_socket_listen },
         { "error",              uc_socket_error },
 };
 
 void uc_module_init(uc_vm_t *vm, uc_value_t *scope)
 {
         uc_function_list_register(scope, global_fns);
 
 #define ADD_CONST(x) ucv_object_add(scope, #x, ucv_int64_new(x))
 
         /**
          * @typedef
          * @name Address Families
          * @description Constants representing address families and socket domains.
          * @property {number} AF_UNSPEC - Unspecified address family.
          * @property {number} AF_UNIX - UNIX domain sockets.
          * @property {number} AF_INET - IPv4 Internet protocols.
          * @property {number} AF_INET6 - IPv6 Internet protocols.
          * @property {number} AF_PACKET - Low-level packet interface.
          */
         ADD_CONST(AF_UNSPEC);
         ADD_CONST(AF_UNIX);
         ADD_CONST(AF_INET);
         ADD_CONST(AF_INET6);
 #if defined(__linux__)
         ADD_CONST(AF_PACKET);
 #endif
 
         /**
          * @typedef
          * @name Socket Types
          * @description
          * The `SOCK_*` type and flag constants are used by
          * {@link module:socket#create|create()} to specify the type of socket to
          * open. The {@link module:socket.socket#accept|accept()} function
          * recognizes the `SOCK_NONBLOCK` and `SOCK_CLOEXEC` flags and applies them
          * to accepted peer sockets.
          * @property {number} SOCK_STREAM - Provides sequenced, reliable, two-way, connection-based byte streams.
          * @property {number} SOCK_DGRAM - Supports datagrams (connectionless, unreliable messages of a fixed maximum length).
          * @property {number} SOCK_RAW - Provides raw network protocol access.
          * @property {number} SOCK_PACKET - Obsolete and should not be used.
          * @property {number} SOCK_NONBLOCK - Enables non-blocking operation.
          * @property {number} SOCK_CLOEXEC - Sets the close-on-exec flag on the new file descriptor.
          */
         ADD_CONST(SOCK_STREAM);
         ADD_CONST(SOCK_DGRAM);
         ADD_CONST(SOCK_RAW);
         ADD_CONST(SOCK_NONBLOCK);
         ADD_CONST(SOCK_CLOEXEC);
 #if defined(__linux__)
         ADD_CONST(SOCK_PACKET);
 #endif
 
         /**
          * @typedef
          * @name Message Flags
          * @description
          * The `MSG_*` flag constants are commonly used in conjunction with the
          * {@link module:socket.socket#send|send()} and
          * {@link module:socket.socket#recv|recv()} functions.
          * @property {number} MSG_CONFIRM - Confirm path validity.
          * @property {number} MSG_DONTROUTE - Send without using routing tables.
          * @property {number} MSG_DONTWAIT - Enables non-blocking operation.
          * @property {number} MSG_EOR - End of record.
          * @property {number} MSG_MORE - Sender will send more.
          * @property {number} MSG_NOSIGNAL - Do not generate SIGPIPE.
          * @property {number} MSG_OOB - Process out-of-band data.
          * @property {number} MSG_FASTOPEN - Send data in TCP SYN.
          * @property {number} MSG_CMSG_CLOEXEC - Sets the close-on-exec flag on the received file descriptor.
          * @property {number} MSG_ERRQUEUE - Receive errors from ICMP.
          * @property {number} MSG_PEEK - Peeks at incoming messages.
          * @property {number} MSG_TRUNC - Report if datagram truncation occurred.
          * @property {number} MSG_WAITALL - Wait for full message.
          */
         ADD_CONST(MSG_DONTROUTE);
         ADD_CONST(MSG_DONTWAIT);
         ADD_CONST(MSG_EOR);
         ADD_CONST(MSG_NOSIGNAL);
         ADD_CONST(MSG_OOB);
         ADD_CONST(MSG_PEEK);
         ADD_CONST(MSG_TRUNC);
         ADD_CONST(MSG_WAITALL);
 #if defined(__linux__)
         ADD_CONST(MSG_CONFIRM);
         ADD_CONST(MSG_MORE);
         ADD_CONST(MSG_FASTOPEN);
         ADD_CONST(MSG_CMSG_CLOEXEC);
         ADD_CONST(MSG_ERRQUEUE);
 #endif
 
         /**
          * @typedef
          * @name IP Protocol Constants
          * @description
          * The `IPPROTO_IP` constant specifies the IP protocol number and may be
          * passed as third argument to {@link module:socket#create|create()} as well
          * as *level* argument value to {@link module:socket.socket#getopt|getopt()}
          * and {@link module:socket.socket#setopt|setopt()}.
          *
          * The `IP_*` constants are option names recognized by
          * {@link module:socket.socket#getopt|getopt()}
          * and {@link module:socket.socket#setopt|setopt()}, in conjunction with
          * the `IPPROTO_IP` socket level.
          * @property {number} IPPROTO_IP - Dummy protocol for IP.
          * @property {number} IP_ADD_MEMBERSHIP - Add an IP group membership.
          * @property {number} IP_ADD_SOURCE_MEMBERSHIP - Add an IP group/source membership.
          * @property {number} IP_BIND_ADDRESS_NO_PORT - Bind to the device only.
          * @property {number} IP_BLOCK_SOURCE - Block IP group/source.
          * @property {number} IP_DROP_MEMBERSHIP - Drop an IP group membership.
          * @property {number} IP_DROP_SOURCE_MEMBERSHIP - Drop an IP group/source membership.
          * @property {number} IP_FREEBIND - Allow binding to an IP address not assigned to a network interface.
          * @property {number} IP_HDRINCL - Header is included with data.
          * @property {number} IP_MSFILTER - Filter IP multicast source memberships.
          * @property {number} IP_MTU - Path MTU discovery.
          * @property {number} IP_MTU_DISCOVER - Control Path MTU discovery.
          * @property {number} IP_MULTICAST_ALL - Receive all multicast packets.
          * @property {number} IP_MULTICAST_IF - Set outgoing interface for multicast packets.
          * @property {number} IP_MULTICAST_LOOP - Control multicast packet looping.
          * @property {number} IP_MULTICAST_TTL - Set time-to-live for outgoing multicast packets.
          * @property {number} IP_NODEFRAG - Don't fragment IP packets.
          * @property {number} IP_OPTIONS - Set/get IP options.
          * @property {number} IP_PASSSEC - Pass security information.
          * @property {number} IP_PKTINFO - Receive packet information.
          * @property {number} IP_RECVERR - Receive all ICMP errors.
          * @property {number} IP_RECVOPTS - Receive all IP options.
          * @property {number} IP_RECVORIGDSTADDR - Receive original destination address of the socket.
          * @property {number} IP_RECVTOS - Receive IP TOS.
          * @property {number} IP_RECVTTL - Receive IP TTL.
          * @property {number} IP_RETOPTS - Set/get IP options.
          * @property {number} IP_ROUTER_ALERT - Receive ICMP msgs generated by router.
          * @property {number} IP_TOS - IP type of service and precedence.
          * @property {number} IP_TRANSPARENT - Transparent proxy support.
          * @property {number} IP_TTL - IP time-to-live.
          * @property {number} IP_UNBLOCK_SOURCE - Unblock IP group/source.
          */
         ADD_CONST(IPPROTO_IP);
         ADD_CONST(IP_ADD_MEMBERSHIP);
         ADD_CONST(IP_ADD_SOURCE_MEMBERSHIP);
         ADD_CONST(IP_BLOCK_SOURCE);
         ADD_CONST(IP_DROP_MEMBERSHIP);
         ADD_CONST(IP_DROP_SOURCE_MEMBERSHIP);
         ADD_CONST(IP_HDRINCL);
         ADD_CONST(IP_MSFILTER);
         ADD_CONST(IP_MULTICAST_IF);
         ADD_CONST(IP_MULTICAST_LOOP);
         ADD_CONST(IP_MULTICAST_TTL);
         ADD_CONST(IP_OPTIONS);
         ADD_CONST(IP_PKTINFO);
         ADD_CONST(IP_RECVOPTS);
         ADD_CONST(IP_RECVTOS);
         ADD_CONST(IP_RECVTTL);
         ADD_CONST(IP_RETOPTS);
         ADD_CONST(IP_TOS);
         ADD_CONST(IP_TTL);
         ADD_CONST(IP_UNBLOCK_SOURCE);
 #if defined(__linux__)
         ADD_CONST(IP_BIND_ADDRESS_NO_PORT);
         ADD_CONST(IP_FREEBIND);
         ADD_CONST(IP_MTU);
         ADD_CONST(IP_MTU_DISCOVER);
         ADD_CONST(IP_MULTICAST_ALL);
         ADD_CONST(IP_NODEFRAG);
         ADD_CONST(IP_PASSSEC);
         ADD_CONST(IP_RECVERR);
         ADD_CONST(IP_RECVORIGDSTADDR);
         ADD_CONST(IP_ROUTER_ALERT);
         ADD_CONST(IP_TRANSPARENT);
 #endif
 
         /**
          * @typedef {Object} IPv6 Protocol Constants
          * @description
          * The `IPPROTO_IPV6` constant specifies the IPv6 protocol number and may be
          * passed as third argument to {@link module:socket#create|create()} as well
          * as *level* argument value to {@link module:socket.socket#getopt|getopt()}
          * and {@link module:socket.socket#setopt|setopt()}.
          *
          * The `IPV6_*` constants are option names recognized by
          * {@link module:socket.socket#getopt|getopt()}
          * and {@link module:socket.socket#setopt|setopt()}, in conjunction with
          * the `IPPROTO_IPV6` socket level.
          * @property {number} IPPROTO_IPV6 - The IPv6 protocol.
          * @property {number} IPV6_ADDRFORM - Turn an AF_INET6 socket into a socket of a different address family. Only AF_INET is supported.
          * @property {number} IPV6_ADDR_PREFERENCES - Specify preferences for address selection.
          * @property {number} IPV6_ADD_MEMBERSHIP - Add an IPv6 group membership.
          * @property {number} IPV6_AUTHHDR - Set delivery of the authentication header control message for incoming datagrams.
          * @property {number} IPV6_AUTOFLOWLABEL - Enable or disable automatic flow labels.
          * @property {number} IPV6_DONTFRAG - Control whether the socket allows IPv6 fragmentation.
          * @property {number} IPV6_DROP_MEMBERSHIP - Drop an IPv6 group membership.
          * @property {number} IPV6_DSTOPTS - Set delivery of the destination options control message for incoming datagrams.
          * @property {number} IPV6_FLOWINFO_SEND - Control whether flow information is sent.
          * @property {number} IPV6_FLOWINFO - Set delivery of the flow ID control message for incoming datagrams.
          * @property {number} IPV6_FLOWLABEL_MGR - Manage flow labels.
          * @property {number} IPV6_FREEBIND - Allow binding to an IP address not assigned to a network interface.
          * @property {number} IPV6_HOPLIMIT - Set delivery of the hop limit control message for incoming datagrams.
          * @property {number} IPV6_HOPOPTS - Set delivery of the hop options control message for incoming datagrams.
          * @property {number} IPV6_JOIN_ANYCAST - Join an anycast group.
          * @property {number} IPV6_LEAVE_ANYCAST - Leave an anycast group.
          * @property {number} IPV6_MINHOPCOUNT - Set the minimum hop count.
          * @property {number} IPV6_MTU - Retrieve or set the MTU to be used for the socket.
          * @property {number} IPV6_MTU_DISCOVER - Control path-MTU discovery on the socket.
          * @property {number} IPV6_MULTICAST_ALL - Control whether the socket receives all multicast packets.
          * @property {number} IPV6_MULTICAST_HOPS - Set the multicast hop limit for the socket.
          * @property {number} IPV6_MULTICAST_IF - Set the device for outgoing multicast packets on the socket.
          * @property {number} IPV6_MULTICAST_LOOP - Control whether the socket sees multicast packets that it has sent itself.
          * @property {number} IPV6_PKTINFO - Set delivery of the IPV6_PKTINFO control message on incoming datagrams.
          * @property {number} IPV6_RECVDSTOPTS - Control receiving of the destination options control message.
          * @property {number} IPV6_RECVERR - Control receiving of asynchronous error options.
          * @property {number} IPV6_RECVFRAGSIZE - Control receiving of fragment size.
          * @property {number} IPV6_RECVHOPLIMIT - Control receiving of hop limit.
          * @property {number} IPV6_RECVHOPOPTS - Control receiving of hop options.
          * @property {number} IPV6_RECVORIGDSTADDR - Control receiving of the original destination address.
          * @property {number} IPV6_RECVPATHMTU - Control receiving of path MTU.
          * @property {number} IPV6_RECVPKTINFO - Control receiving of packet information.
          * @property {number} IPV6_RECVRTHDR - Control receiving of routing header.
          * @property {number} IPV6_RECVTCLASS - Control receiving of traffic class.
          * @property {number} IPV6_ROUTER_ALERT_ISOLATE - Control isolation of router alert messages.
          * @property {number} IPV6_ROUTER_ALERT - Pass forwarded packets containing a router alert hop-by-hop option to this socket.
          * @property {number} IPV6_RTHDR - Set delivery of the routing header control message for incoming datagrams.
          * @property {number} IPV6_RTHDRDSTOPTS - Set delivery of the routing header destination options control message.
          * @property {number} IPV6_TCLASS - Set the traffic class.
          * @property {number} IPV6_TRANSPARENT - Enable transparent proxy support.
          * @property {number} IPV6_UNICAST_HOPS - Set the unicast hop limit for the socket.
          * @property {number} IPV6_UNICAST_IF - Set the interface for outgoing unicast packets.
          * @property {number} IPV6_V6ONLY - Restrict the socket to sending and receiving IPv6 packets only.
          */
         ADD_CONST(IPPROTO_IPV6);
         ADD_CONST(IPV6_FLOWINFO_SEND);
         ADD_CONST(IPV6_FLOWINFO);
         ADD_CONST(IPV6_FLOWLABEL_MGR);
         ADD_CONST(IPV6_MULTICAST_HOPS);
         ADD_CONST(IPV6_MULTICAST_IF);
         ADD_CONST(IPV6_MULTICAST_LOOP);
         ADD_CONST(IPV6_RECVTCLASS);
         ADD_CONST(IPV6_TCLASS);
         ADD_CONST(IPV6_UNICAST_HOPS);
         ADD_CONST(IPV6_V6ONLY);
 #if defined(__linux__)
         ADD_CONST(IPV6_ADD_MEMBERSHIP);
         ADD_CONST(IPV6_ADDR_PREFERENCES);
         ADD_CONST(IPV6_ADDRFORM);
         ADD_CONST(IPV6_AUTHHDR);
         ADD_CONST(IPV6_AUTOFLOWLABEL);
         ADD_CONST(IPV6_DONTFRAG);
         ADD_CONST(IPV6_DROP_MEMBERSHIP);
         ADD_CONST(IPV6_DSTOPTS);
         ADD_CONST(IPV6_FREEBIND);
         ADD_CONST(IPV6_HOPLIMIT);
         ADD_CONST(IPV6_HOPOPTS);
         ADD_CONST(IPV6_JOIN_ANYCAST);
         ADD_CONST(IPV6_LEAVE_ANYCAST);
         ADD_CONST(IPV6_MINHOPCOUNT);
         ADD_CONST(IPV6_MTU_DISCOVER);
         ADD_CONST(IPV6_MTU);
         ADD_CONST(IPV6_MULTICAST_ALL);
         ADD_CONST(IPV6_PKTINFO);
         ADD_CONST(IPV6_RECVDSTOPTS);
         ADD_CONST(IPV6_RECVERR);
         ADD_CONST(IPV6_RECVFRAGSIZE);
         ADD_CONST(IPV6_RECVHOPLIMIT);
         ADD_CONST(IPV6_RECVHOPOPTS);
         ADD_CONST(IPV6_RECVORIGDSTADDR);
         ADD_CONST(IPV6_RECVPATHMTU);
         ADD_CONST(IPV6_RECVPKTINFO);
         ADD_CONST(IPV6_RECVRTHDR);
         ADD_CONST(IPV6_ROUTER_ALERT_ISOLATE);
         ADD_CONST(IPV6_ROUTER_ALERT);
         ADD_CONST(IPV6_RTHDR);
         ADD_CONST(IPV6_RTHDRDSTOPTS);
         ADD_CONST(IPV6_TRANSPARENT);
         ADD_CONST(IPV6_UNICAST_IF);
 #endif
 
         /**
          * @typedef
          * @name Socket Option Constants
          * @description
          * The `SOL_SOCKET` constant is passed as *level* argument to the
          * {@link module:socket.socket#getopt|getopt()} and
          * {@link module:socket.socket#setopt|setopt()} functions in order to set
          * or retrieve generic socket option values.
          *
          * The `SO_*` constants are passed as *option* argument in conjunction with
          * the `SOL_SOCKET` level to specify the specific option to get or set on
          * the socket.
          * @property {number} SOL_SOCKET - Socket options at the socket API level.
          * @property {number} SO_ACCEPTCONN - Reports whether socket listening is enabled.
          * @property {number} SO_ATTACH_BPF - Attach BPF program to socket.
          * @property {number} SO_ATTACH_FILTER - Attach a socket filter.
          * @property {number} SO_ATTACH_REUSEPORT_CBPF - Attach BPF program for cgroup and skb program reuseport hook.
          * @property {number} SO_ATTACH_REUSEPORT_EBPF - Attach eBPF program for cgroup and skb program reuseport hook.
          * @property {number} SO_BINDTODEVICE - Bind socket to a specific interface.
          * @property {number} SO_BROADCAST - Allow transmission of broadcast messages.
          * @property {number} SO_BUSY_POLL - Enable busy polling.
          * @property {number} SO_DEBUG - Enable socket debugging.
          * @property {number} SO_DETACH_BPF - Detach BPF program from socket.
          * @property {number} SO_DETACH_FILTER - Detach a socket filter.
          * @property {number} SO_DOMAIN - Retrieves the domain of the socket.
          * @property {number} SO_DONTROUTE - Send packets directly without routing.
          * @property {number} SO_ERROR - Retrieves and clears the error status for the socket.
          * @property {number} SO_INCOMING_CPU - Retrieves the CPU number on which the last packet was received.
          * @property {number} SO_INCOMING_NAPI_ID - Retrieves the NAPI ID of the device.
          * @property {number} SO_KEEPALIVE - Enable keep-alive packets.
          * @property {number} SO_LINGER - Set linger on close.
          * @property {number} SO_LOCK_FILTER - Set or get the socket filter lock state.
          * @property {number} SO_MARK - Set the mark for packets sent through the socket.
          * @property {number} SO_OOBINLINE - Enables out-of-band data to be received in the normal data stream.
          * @property {number} SO_PASSCRED - Enable the receiving of SCM_CREDENTIALS control messages.
          * @property {number} SO_PASSSEC - Enable the receiving of security context.
          * @property {number} SO_PEEK_OFF - Returns the number of bytes in the receive buffer without removing them.
          * @property {number} SO_PEERCRED - Retrieves the credentials of the foreign peer.
          * @property {number} SO_PEERSEC - Retrieves the security context of the foreign peer.
          * @property {number} SO_PRIORITY - Set the protocol-defined priority for all packets.
          * @property {number} SO_PROTOCOL - Retrieves the protocol number.
          * @property {number} SO_RCVBUF - Set the receive buffer size.
          * @property {number} SO_RCVBUFFORCE - Set the receive buffer size forcefully.
          * @property {number} SO_RCVLOWAT - Set the minimum number of bytes to process for input operations.
          * @property {number} SO_RCVTIMEO - Set the timeout for receiving data.
          * @property {number} SO_REUSEADDR - Allow the socket to be bound to an address that is already in use.
          * @property {number} SO_REUSEPORT - Enable duplicate address and port bindings.
          * @property {number} SO_RXQ_OVFL - Reports if the receive queue has overflown.
          * @property {number} SO_SNDBUF - Set the send buffer size.
          * @property {number} SO_SNDBUFFORCE - Set the send buffer size forcefully.
          * @property {number} SO_SNDLOWAT - Set the minimum number of bytes to process for output operations.
          * @property {number} SO_SNDTIMEO - Set the timeout for sending data.
          * @property {number} SO_TIMESTAMP - Enable receiving of timestamps.
          * @property {number} SO_TIMESTAMPNS - Enable receiving of nanosecond timestamps.
          * @property {number} SO_TYPE - Retrieves the type of the socket (e.g., SOCK_STREAM).
          */
         ADD_CONST(SOL_SOCKET);
         ADD_CONST(SO_ACCEPTCONN);
         ADD_CONST(SO_BROADCAST);
         ADD_CONST(SO_DEBUG);
         ADD_CONST(SO_DONTROUTE);
         ADD_CONST(SO_ERROR);
         ADD_CONST(SO_KEEPALIVE);
         ADD_CONST(SO_LINGER);
         ADD_CONST(SO_OOBINLINE);
         ADD_CONST(SO_RCVBUF);
         ADD_CONST(SO_RCVLOWAT);
         ADD_CONST(SO_RCVTIMEO);
         ADD_CONST(SO_REUSEADDR);
         ADD_CONST(SO_REUSEPORT);
         ADD_CONST(SO_SNDBUF);
         ADD_CONST(SO_SNDLOWAT);
         ADD_CONST(SO_SNDTIMEO);
         ADD_CONST(SO_TIMESTAMP);
         ADD_CONST(SO_TYPE);
 #if defined(__linux__)
         ADD_CONST(SO_ATTACH_BPF);
         ADD_CONST(SO_ATTACH_FILTER);
         ADD_CONST(SO_ATTACH_REUSEPORT_CBPF);
         ADD_CONST(SO_ATTACH_REUSEPORT_EBPF);
         ADD_CONST(SO_BINDTODEVICE);
         ADD_CONST(SO_BUSY_POLL);
         ADD_CONST(SO_DETACH_BPF);
         ADD_CONST(SO_DETACH_FILTER);
         ADD_CONST(SO_DOMAIN);
         ADD_CONST(SO_INCOMING_CPU);
         ADD_CONST(SO_INCOMING_NAPI_ID);
         ADD_CONST(SO_LOCK_FILTER);
         ADD_CONST(SO_MARK);
         ADD_CONST(SO_PASSCRED);
         ADD_CONST(SO_PASSSEC);
         ADD_CONST(SO_PEEK_OFF);
         ADD_CONST(SO_PEERCRED);
         ADD_CONST(SO_PEERSEC);
         ADD_CONST(SO_PRIORITY);
         ADD_CONST(SO_PROTOCOL);
         ADD_CONST(SO_RCVBUFFORCE);
         ADD_CONST(SO_RXQ_OVFL);
         ADD_CONST(SO_SNDBUFFORCE);
         ADD_CONST(SO_TIMESTAMPNS);
 
         ADD_CONST(SCM_CREDENTIALS);
         ADD_CONST(SCM_RIGHTS);
 #endif
 
         /**
          * @typedef
          * @name TCP Protocol Constants
          * @description
          * The `IPPROTO_TCP` constant specifies the TCP protocol number and may be
          * passed as third argument to {@link module:socket#create|create()} as well
          * as *level* argument value to {@link module:socket.socket#getopt|getopt()}
          * and {@link module:socket.socket#setopt|setopt()}.
          *
          * The `TCP_*` constants are *option* argument values recognized by
          * {@link module:socket.socket#getopt|getopt()}
          * and {@link module:socket.socket#setopt|setopt()}, in conjunction with
          * the `IPPROTO_TCP` socket level.
          * @property {number} IPPROTO_TCP - TCP protocol.
          * @property {number} TCP_CONGESTION - Set the congestion control algorithm.
          * @property {number} TCP_CORK - Delay packet transmission until full-sized packets are available.
          * @property {number} TCP_DEFER_ACCEPT - Delay accepting incoming connections until data arrives.
          * @property {number} TCP_FASTOPEN - Enable TCP Fast Open.
          * @property {number} TCP_FASTOPEN_CONNECT - Perform TFO connect.
          * @property {number} TCP_INFO - Retrieve TCP statistics.
          * @property {number} TCP_KEEPCNT - Number of keepalive probes.
          * @property {number} TCP_KEEPIDLE - Time before keepalive probes begin.
          * @property {number} TCP_KEEPINTVL - Interval between keepalive probes.
          * @property {number} TCP_LINGER2 - Lifetime of orphaned FIN_WAIT2 state sockets.
          * @property {number} TCP_MAXSEG - Maximum segment size.
          * @property {number} TCP_NODELAY - Disable Nagle's algorithm.
          * @property {number} TCP_QUICKACK - Enable quick ACKs.
          * @property {number} TCP_SYNCNT - Number of SYN retransmits.
          * @property {number} TCP_USER_TIMEOUT - Set the user timeout.
          * @property {number} TCP_WINDOW_CLAMP - Set the maximum window.
          */
         ADD_CONST(IPPROTO_TCP);
         ADD_CONST(TCP_FASTOPEN);
         ADD_CONST(TCP_KEEPCNT);
         ADD_CONST(TCP_KEEPINTVL);
         ADD_CONST(TCP_MAXSEG);
         ADD_CONST(TCP_NODELAY);
 #if defined(__linux__)
         ADD_CONST(TCP_CONGESTION);
         ADD_CONST(TCP_CORK);
         ADD_CONST(TCP_DEFER_ACCEPT);
         ADD_CONST(TCP_FASTOPEN_CONNECT);
         ADD_CONST(TCP_INFO);
         ADD_CONST(TCP_KEEPIDLE);
         ADD_CONST(TCP_LINGER2);
         ADD_CONST(TCP_QUICKACK);
         ADD_CONST(TCP_SYNCNT);
         ADD_CONST(TCP_USER_TIMEOUT);
         ADD_CONST(TCP_WINDOW_CLAMP);
 #endif
 
         /**
          * @typedef
          * @name Packet Socket Constants
          * @description
          * The `SOL_PACKET` constant specifies the packet socket level and may be
          * passed as *level* argument value to
          * {@link module:socket.socket#getopt|getopt()} and
          * {@link module:socket.socket#setopt|setopt()}.
          *
          * Most `PACKET_*` constants are *option* argument values recognized by
          * {@link module:socket.socket#getopt|getopt()}
          * and {@link module:socket.socket#setopt|setopt()}, in conjunction with
          * the `SOL_PACKET` socket level.
          *
          * The constants `PACKET_MR_PROMISC`, `PACKET_MR_MULTICAST` and
          * `PACKET_MR_ALLMULTI` are used in conjunction with the
          * `PACKET_ADD_MEMBERSHIP` and `PACKET_DROP_MEMBERSHIP` options to specify
          * the packet socket receive mode.
          *
          * The constants `PACKET_HOST`, `PACKET_BROADCAST`, `PACKET_MULTICAST`,
          * `PACKET_OTHERHOST` and `PACKET_OUTGOING` may be used as *packet_type*
          * value in {@link module:socket.socket.SocketAddress|socket address}
          * structures.
          * @property {number} SOL_PACKET - Socket options at the packet API level.
          * @property {number} PACKET_ADD_MEMBERSHIP - Add a multicast group membership.
          * @property {number} PACKET_DROP_MEMBERSHIP - Drop a multicast group membership.
          * @property {number} PACKET_AUXDATA - Receive auxiliary data (packet info).
          * @property {number} PACKET_FANOUT - Configure packet fanout.
          * @property {number} PACKET_LOSS - Retrieve the current packet loss statistics.
          * @property {number} PACKET_RESERVE - Reserve space for packet headers.
          * @property {number} PACKET_RX_RING - Configure a receive ring buffer.
          * @property {number} PACKET_STATISTICS - Retrieve packet statistics.
          * @property {number} PACKET_TIMESTAMP - Retrieve packet timestamps.
          * @property {number} PACKET_TX_RING - Configure a transmit ring buffer.
          * @property {number} PACKET_VERSION - Set the packet protocol version.
          * @property {number} PACKET_QDISC_BYPASS - Bypass queuing discipline for outgoing packets.
          *
          * @property {number} PACKET_MR_PROMISC - Enable promiscuous mode.
          * @property {number} PACKET_MR_MULTICAST - Receive multicast packets.
          * @property {number} PACKET_MR_ALLMULTI - Receive all multicast packets.
          *
          * @property {number} PACKET_HOST - Receive packets destined for this host.
          * @property {number} PACKET_BROADCAST - Receive broadcast packets.
          * @property {number} PACKET_MULTICAST - Receive multicast packets.
          * @property {number} PACKET_OTHERHOST - Receive packets destined for other hosts.
          * @property {number} PACKET_OUTGOING - Transmit packets.
          */
 #if defined(__linux__)
         ADD_CONST(SOL_PACKET);
         ADD_CONST(PACKET_ADD_MEMBERSHIP);
         ADD_CONST(PACKET_DROP_MEMBERSHIP);
         ADD_CONST(PACKET_AUXDATA);
         ADD_CONST(PACKET_FANOUT);
         ADD_CONST(PACKET_LOSS);
         ADD_CONST(PACKET_RESERVE);
         ADD_CONST(PACKET_RX_RING);
         ADD_CONST(PACKET_STATISTICS);
         ADD_CONST(PACKET_TIMESTAMP);
         ADD_CONST(PACKET_TX_RING);
         ADD_CONST(PACKET_VERSION);
         ADD_CONST(PACKET_QDISC_BYPASS);
 
         ADD_CONST(PACKET_MR_PROMISC);
         ADD_CONST(PACKET_MR_MULTICAST);
         ADD_CONST(PACKET_MR_ALLMULTI);
 
         ADD_CONST(PACKET_HOST);
         ADD_CONST(PACKET_BROADCAST);
         ADD_CONST(PACKET_MULTICAST);
         ADD_CONST(PACKET_OTHERHOST);
         ADD_CONST(PACKET_OUTGOING);
 #endif
 
         /**
          * @typedef
          * @name UDP Protocol Constants
          * @description
          * The `IPPROTO_UDP` constant specifies the UDP protocol number and may be
          * passed as third argument to {@link module:socket#create|create()} as well
          * as *level* argument value to {@link module:socket.socket#getopt|getopt()}
          * and {@link module:socket.socket#setopt|setopt()}.
          *
          * The `UDP_*` constants are *option* argument values recognized by
          * {@link module:socket.socket#getopt|getopt()}
          * and {@link module:socket.socket#setopt|setopt()}, in conjunction with
          * the `IPPROTO_UDP` socket level.
          * @property {number} IPPROTO_UDP - UDP protocol.
          * @property {number} UDP_CORK - Cork data until flush.
          */
         ADD_CONST(IPPROTO_UDP);
 #if defined(__linux__)
         ADD_CONST(UDP_CORK);
 #endif
 
         /**
          * @typedef
          * @name Shutdown Constants
          * @description
          * The `SHUT_*` constants are passed as argument to the
          * {@link module:socket.socket#shutdown|shutdown()} function to specify
          * which direction of a full duplex connection to shut down.
          * @property {number} SHUT_RD - Disallow further receptions.
          * @property {number} SHUT_WR - Disallow further transmissions.
          * @property {number} SHUT_RDWR - Disallow further receptions and transmissions.
          */
         ADD_CONST(SHUT_RD);
         ADD_CONST(SHUT_WR);
         ADD_CONST(SHUT_RDWR);
 
         /**
          * @typedef
          * @name Address Info Flags
          * @description
          * The `AI_*` flags may be passed as bitwise OR-ed number in the *flags*
          * property of the *hints* dictionary argument of
          * {@link module:socket#addrinfo|addrinfo()}.
          * @property {number} AI_ADDRCONFIG - Address configuration flag.
          * @property {number} AI_ALL - Return IPv4 and IPv6 socket addresses.
          * @property {number} AI_CANONIDN - Canonicalize using the IDNA standard.
          * @property {number} AI_CANONNAME - Fill in the canonical name field.
          * @property {number} AI_IDN - Enable IDN encoding.
          * @property {number} AI_NUMERICHOST - Prevent hostname resolution.
          * @property {number} AI_NUMERICSERV - Prevent service name resolution.
          * @property {number} AI_PASSIVE - Use passive socket.
          * @property {number} AI_V4MAPPED - Map IPv6 addresses to IPv4-mapped format.
          */
         ADD_CONST(AI_ADDRCONFIG);
         ADD_CONST(AI_ALL);
         ADD_CONST(AI_CANONIDN);
         ADD_CONST(AI_CANONNAME);
         ADD_CONST(AI_IDN);
         ADD_CONST(AI_NUMERICHOST);
         ADD_CONST(AI_NUMERICSERV);
         ADD_CONST(AI_PASSIVE);
         ADD_CONST(AI_V4MAPPED);
 
         /**
          * @typedef
          * @name Name Info Constants
          * @description
          * The `NI_*` flags may be passed as bitwise OR-ed number via the *flags*
          * argument of {@link module:socket#nameinfo|nameinfo()}.
          * @property {number} NI_DGRAM - Datagram socket type.
          * @property {number} NI_IDN - Enable IDN encoding.
          * @property {number} NI_NAMEREQD - Hostname resolution required.
          * @property {number} NI_NOFQDN - Do not force fully qualified domain name.
          * @property {number} NI_NUMERICHOST - Return numeric form of the hostname.
          * @property {number} NI_NUMERICSERV - Return numeric form of the service name.
          */
         ADD_CONST(NI_DGRAM);
         ADD_CONST(NI_IDN);
         ADD_CONST(NI_MAXHOST);
         ADD_CONST(NI_MAXSERV);
         ADD_CONST(NI_NAMEREQD);
         ADD_CONST(NI_NOFQDN);
         ADD_CONST(NI_NUMERICHOST);
         ADD_CONST(NI_NUMERICSERV);
 
         /**
          * @typedef
          * @name Poll Event Constants
          * @description
          * The following constants represent event types for polling operations and
          * are set or returned as part of a
          * {@link module:socket.PollSpec|PollSpec} tuple by the
          * {@link module:socket#poll|poll()} function. When passed via an argument
          * PollSpec to `poll()`, they specify the I/O events to watch for on the
          * corresponding handle. When appearing in a PollSpec returned by `poll()`,
          * they specify the I/O events that occurred on a watched handle.
          * @property {number} POLLIN - Data available to read.
          * @property {number} POLLPRI - Priority data available to read.
          * @property {number} POLLOUT - Writable data available.
          * @property {number} POLLERR - Error condition.
          * @property {number} POLLHUP - Hang up.
          * @property {number} POLLNVAL - Invalid request.
          * @property {number} POLLRDHUP - Peer closed or shutdown writing.
          */
         ADD_CONST(POLLIN);
         ADD_CONST(POLLPRI);
         ADD_CONST(POLLOUT);
         ADD_CONST(POLLERR);
         ADD_CONST(POLLHUP);
         ADD_CONST(POLLNVAL);
 #if defined(__linux__)
         ADD_CONST(POLLRDHUP);
 #endif
 
         uc_type_declare(vm, "socket", socket_fns, close_socket);
 }