/*
    * 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 <sys/types.h>
  #include <sys/socket.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 "ucode/module.h"
  #include "ucode/platform.h"
  
  #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
  
  #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)
 {
         uc_string_t *us = (uc_string_t *)(*sb)->buf;
         size_t buffer_size = strbuf_size(*sb);
 
         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;
 }
 
 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;
 
         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;
         }
 
         return false;
 }
 
 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;
         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) {
                         *slen = ucv_string_length(addr);
 
                         if (*slen >= sizeof(su->sun_path))
                                 *slen = sizeof(su->sun_path) - 1;
 
                         memcpy(su->sun_path, s, *slen);
                         su->sun_path[(*slen)++] = 0;
                         su->sun_family = AF_UNIX;
 
                         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 = len;
 
                         ok_return(true);
                 }
         }
 
         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 bool
 uv_to_pollfd(uc_vm_t *vm, uc_value_t *val, struct pollfd *pfd)
 {
         int64_t flags;
 
         if (ucv_type(val) == UC_ARRAY) {
                 if (!uv_to_fileno(vm, ucv_array_get(val, 0), &pfd->fd))
                         return false;
 
                 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;
         }
         else {
                 if (!uv_to_fileno(vm, val, &pfd->fd))
                         return false;
 
                 pfd->events = POLLIN | POLLERR | POLLHUP;
                 pfd->revents = 0;
         }
 
         return true;
 }
 
 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_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;
 
 #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 }
         }
 };
 
 #if defined(__linux__)
 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 }
         }
 };
 
 #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
 
 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_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
 };
 
 
 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_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("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_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;
 
                 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;
         int sockfd, solvl, soopt, soval, ret;
         void *valptr = NULL, *st = NULL;
         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);
         soval = 0;
 
         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:
                         valptr = &soval;
                         vallen = sizeof(int);
                         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) {
                 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(soval);
                         break;
 
                 case (uintptr_t)SV_BOOL:
                         value = ucv_boolean_new(soval);
                         break;
 
                 case (uintptr_t)SV_STRING:
                         value = strbuf_finish(&sb, vallen);
                         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 or AF_UNIX.
  *
  * @property {string} address
  * IPv4 or IPv6 address string (AF_INET or AF_INET6 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, either a network device name string or a nonzero
  * positive integer representing a network interface index (AF_INET6 only).
  *
  * @property {string} path
  * Domain socket filesystem path (AF_UNIX 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 = (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 poll states.
  * 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 a `[socket, flags]` tuple
  * specifying the socket and requested poll flags. If a plain socket and not a
  * tuple is provided, the requested poll flags default to
  * `POLLIN|POLLERR|POLLHUP` for this socket.
  *
  * @returns {module:socket.PollSpec[]}
  */
 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);
 
                 if (uv_to_pollfd(vm, uc_fn_arg(i), &pfds.entries[pfds.count])) {
                         item = ucv_array_new_length(vm, 2);
                         ucv_array_set(item, 0, ucv_get(uc_fn_arg(i)));
                         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);
 }
 
 /**
  * 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 (ucv_type(host) == UC_STRING) {
                 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))
                         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 || ucv_type(host) == UC_STRING) {
                 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);
                 }
 
                 socktype = ai_hints ? ai_hints->ai_socktype : SOCK_STREAM;
                 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) {
                 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 socket and returns its hand
  *
  * The handle will be connected to the process stdin or stdout, depending on the
  * value of the mode argument.
  *
  * The mode argument may be either "r" to open the process for reading (connect
  * to its stdin) or "w" to open the process for writing (connect to its stdout).
  *
  * The mode character "r" or "w" may be optionally followed by "e" to apply the
  * FD_CLOEXEC flag onto the open descriptor.
  *
  * Returns a process handle referring to the executed process.
  *
  * Returns `null` if an error occurred.
  *
  * @function module:fs#popen
  *
  * @param {string} command
  * The command to be executed.
  *
  * @param {string} [mode="r"]
  * The open mode of the process handle.
  *
  * @returns {?module:fs.proc}
  *
  * @example
  * // Open a process
  * const process = popen('command', 'r');
  */
 
 /**
  * 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));
 }
 
 /**
  * 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 },
         { "recv",           uc_socket_inst_recv },
         { "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
          * @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);
 #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 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);
 }
 

• Git
• Wiki