diff options
Diffstat (limited to 'libc-bottom-half')
34 files changed, 10601 insertions, 81 deletions
diff --git a/libc-bottom-half/cloudlibc/src/libc/poll/poll.c b/libc-bottom-half/cloudlibc/src/libc/poll/poll.c index cde4e81..0ee1479 100644 --- a/libc-bottom-half/cloudlibc/src/libc/poll/poll.c +++ b/libc-bottom-half/cloudlibc/src/libc/poll/poll.c @@ -7,7 +7,7 @@ #include <poll.h> #include <stdbool.h> -int poll(struct pollfd *fds, size_t nfds, int timeout) { +static int poll_wasip1(struct pollfd *fds, size_t nfds, int timeout) { // Construct events for poll(). size_t maxevents = 2 * nfds + 1; __wasi_subscription_t subscriptions[maxevents]; @@ -127,3 +127,48 @@ int poll(struct pollfd *fds, size_t nfds, int timeout) { } return retval; } + +#ifdef __wasilibc_use_wasip2 +#include <wasi/descriptor_table.h> + +int poll_wasip2(struct pollfd *fds, size_t nfds, int timeout); + +int poll(struct pollfd* fds, nfds_t nfds, int timeout) +{ + bool found_socket = false; + bool found_non_socket = false; + for (size_t i = 0; i < nfds; ++i) { + descriptor_table_entry_t* entry; + if (descriptor_table_get_ref(fds[i].fd, &entry)) { + found_socket = true; + } else { + found_non_socket = true; + } + } + + if (found_socket) { + if (found_non_socket) { + // We currently don't support polling a mix of non-sockets and + // sockets here (though you can do it by using the host APIs + // directly), and we probably won't until we've migrated entirely to + // WASI 0.2. + errno = ENOTSUP; + return -1; + } + + return poll_wasip2(fds, nfds, timeout); + } else if (found_non_socket) { + return poll_wasip1(fds, nfds, timeout); + } else if (timeout >= 0) { + return poll_wasip2(fds, nfds, timeout); + } else { + errno = ENOTSUP; + return -1; + } +} +#else // not __wasilibc_use_wasip2 +int poll(struct pollfd* fds, nfds_t nfds, int timeout) +{ + return poll_wasip1(fds, nfds, timeout); +} +#endif // not __wasilibc_use_wasip2 diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/ioctl/ioctl.c b/libc-bottom-half/cloudlibc/src/libc/sys/ioctl/ioctl.c index 7d03cc6..2c968b2 100644 --- a/libc-bottom-half/cloudlibc/src/libc/sys/ioctl/ioctl.c +++ b/libc-bottom-half/cloudlibc/src/libc/sys/ioctl/ioctl.c @@ -4,11 +4,66 @@ #include <sys/ioctl.h> -#include <wasi/api.h> #include <errno.h> #include <stdarg.h> +#include <wasi/api.h> +#ifdef __wasilibc_use_wasip2 +#include <wasi/descriptor_table.h> +#endif + int ioctl(int fildes, int request, ...) { +#ifdef __wasilibc_use_wasip2 + descriptor_table_entry_t *entry; + if (descriptor_table_get_ref(fildes, &entry)) { + switch (entry->tag) { + case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET: { + tcp_socket_t *socket = &entry->tcp_socket; + switch (request) { + case FIONBIO: { + va_list ap; + va_start(ap, request); + socket->blocking = *va_arg(ap, const int *) == + 0; + va_end(ap); + + return 0; + } + + default: + // TODO wasi-sockets: anything else we should support? + errno = EINVAL; + return -1; + } + } + + case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET: { + udp_socket_t *socket = &entry->udp_socket; + switch (request) { + case FIONBIO: { + va_list ap; + va_start(ap, request); + socket->blocking = *va_arg(ap, const int *) == + 0; + va_end(ap); + + return 0; + } + + default: + // TODO wasi-sockets: anything else we should support? + errno = EINVAL; + return -1; + } + } + + default: + errno = ENOPROTOOPT; + return -1; + } + } +#endif // __wasilibc_use_wasip2 + switch (request) { case FIONREAD: { // Poll the file descriptor to determine how many bytes can be read. diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/select/pselect.c b/libc-bottom-half/cloudlibc/src/libc/sys/select/pselect.c index fdc470e..3b479ed 100644 --- a/libc-bottom-half/cloudlibc/src/libc/sys/select/pselect.c +++ b/libc-bottom-half/cloudlibc/src/libc/sys/select/pselect.c @@ -8,6 +8,7 @@ #include <wasi/api.h> #include <errno.h> +#include <poll.h> int pselect(int nfds, fd_set *restrict readfds, fd_set *restrict writefds, fd_set *restrict errorfds, const struct timespec *restrict timeout, @@ -33,93 +34,66 @@ int pselect(int nfds, fd_set *restrict readfds, fd_set *restrict writefds, if (writefds == NULL) writefds = ∅ - // Determine the maximum number of events. - size_t maxevents = readfds->__nfds + writefds->__nfds + 1; - __wasi_subscription_t subscriptions[maxevents]; - size_t nsubscriptions = 0; - - // Convert the readfds set. + struct pollfd poll_fds[readfds->__nfds + writefds->__nfds]; + size_t poll_nfds = 0; + for (size_t i = 0; i < readfds->__nfds; ++i) { int fd = readfds->__fds[i]; if (fd < nfds) { - __wasi_subscription_t *subscription = &subscriptions[nsubscriptions++]; - *subscription = (__wasi_subscription_t){ - .userdata = fd, - .u.tag = __WASI_EVENTTYPE_FD_READ, - .u.u.fd_read.file_descriptor = fd, - }; + poll_fds[poll_nfds++] = (struct pollfd){ + .fd = fd, + .events = POLLRDNORM, + .revents = 0 + }; } } - - // Convert the writefds set. + for (size_t i = 0; i < writefds->__nfds; ++i) { int fd = writefds->__fds[i]; if (fd < nfds) { - __wasi_subscription_t *subscription = &subscriptions[nsubscriptions++]; - *subscription = (__wasi_subscription_t){ - .userdata = fd, - .u.tag = __WASI_EVENTTYPE_FD_WRITE, - .u.u.fd_write.file_descriptor = fd, + poll_fds[poll_nfds++] = (struct pollfd){ + .fd = fd, + .events = POLLWRNORM, + .revents = 0 }; } } - // Create extra event for the timeout. - if (timeout != NULL) { - __wasi_subscription_t *subscription = &subscriptions[nsubscriptions++]; - *subscription = (__wasi_subscription_t){ - .u.tag = __WASI_EVENTTYPE_CLOCK, - .u.u.clock.id = __WASI_CLOCKID_REALTIME, - }; - if (!timespec_to_timestamp_clamp(timeout, &subscription->u.u.clock.timeout)) { + int poll_timeout; + if (timeout) { + uint64_t timeout_u64; + if (!timespec_to_timestamp_clamp(timeout, &timeout_u64) ) { errno = EINVAL; return -1; } - } - // Execute poll(). - size_t nevents; - __wasi_event_t events[nsubscriptions]; - __wasi_errno_t error = - __wasi_poll_oneoff(subscriptions, events, nsubscriptions, &nevents); - if (error != 0) { - // WASI's poll requires at least one subscription, or else it returns - // `EINVAL`. Since a `pselect` with nothing to wait for is valid in POSIX, - // return `ENOTSUP` to indicate that we don't support that case. - // - // Wasm has no signal handling, so if none of the user-provided `pollfd` - // elements, nor the timeout, led us to producing even one subscription - // to wait for, there would be no way for the poll to wake up. WASI - // returns `EINVAL` in this case, but for users of `poll`, `ENOTSUP` is - // more likely to be understood. - if (nsubscriptions == 0) - errno = ENOTSUP; - else - errno = error; - return -1; - } + // Convert nanoseconds to milliseconds: + timeout_u64 /= 1000000; - // Test for EBADF. - for (size_t i = 0; i < nevents; ++i) { - const __wasi_event_t *event = &events[i]; - if ((event->type == __WASI_EVENTTYPE_FD_READ || - event->type == __WASI_EVENTTYPE_FD_WRITE) && - event->error == __WASI_ERRNO_BADF) { - errno = EBADF; - return -1; + if (timeout_u64 > INT_MAX) { + timeout_u64 = INT_MAX; } + + poll_timeout = (int) timeout_u64; + } else { + poll_timeout = -1; + }; + + if (poll(poll_fds, poll_nfds, poll_timeout) < 0) { + return -1; } - // Clear and set entries in the result sets. FD_ZERO(readfds); FD_ZERO(writefds); - for (size_t i = 0; i < nevents; ++i) { - const __wasi_event_t *event = &events[i]; - if (event->type == __WASI_EVENTTYPE_FD_READ) { - readfds->__fds[readfds->__nfds++] = event->userdata; - } else if (event->type == __WASI_EVENTTYPE_FD_WRITE) { - writefds->__fds[writefds->__nfds++] = event->userdata; + for (size_t i = 0; i < poll_nfds; ++i) { + struct pollfd* pollfd = poll_fds + i; + if ((pollfd->revents & POLLRDNORM) != 0) { + readfds->__fds[readfds->__nfds++] = pollfd->fd; + } + if ((pollfd->revents & POLLWRNORM) != 0) { + writefds->__fds[writefds->__nfds++] = pollfd->fd; } } + return readfds->__nfds + writefds->__nfds; } diff --git a/libc-bottom-half/crt/crt1-command.c b/libc-bottom-half/crt/crt1-command.c index fb9ee71..d2030cb 100644 --- a/libc-bottom-half/crt/crt1-command.c +++ b/libc-bottom-half/crt/crt1-command.c @@ -20,18 +20,18 @@ void _start(void) { static volatile _Atomic int started = 0; int expected = 0; if (!atomic_compare_exchange_strong(&started, &expected, 1)) { - __builtin_trap(); + __builtin_trap(); } #else static volatile int started = 0; if (started != 0) { - __builtin_trap(); + __builtin_trap(); } started = 1; #endif #ifdef _REENTRANT - __wasi_init_tp(); + __wasi_init_tp(); #endif // The linker synthesizes this to call constructors. diff --git a/libc-bottom-half/headers/private/wasi/descriptor_table.h b/libc-bottom-half/headers/private/wasi/descriptor_table.h new file mode 100644 index 0000000..8e9a90d --- /dev/null +++ b/libc-bottom-half/headers/private/wasi/descriptor_table.h @@ -0,0 +1,127 @@ +#ifndef DESCRIPTOR_TABLE_H +#define DESCRIPTOR_TABLE_H + +#include <wasi/wasip2.h> + +typedef struct { + int dummy; +} tcp_socket_state_unbound_t; +typedef struct { + int dummy; +} tcp_socket_state_bound_t; +typedef struct { + int dummy; +} tcp_socket_state_connecting_t; +typedef struct { + int dummy; +} tcp_socket_state_listening_t; + +typedef struct { + streams_own_input_stream_t input; + poll_own_pollable_t input_pollable; + streams_own_output_stream_t output; + poll_own_pollable_t output_pollable; +} tcp_socket_state_connected_t; + +typedef struct { + network_error_code_t error_code; +} tcp_socket_state_connect_failed_t; + +// This is a tagged union. When adding/removing/renaming cases, be sure to keep the tag and union definitions in sync. +typedef struct { + enum { + TCP_SOCKET_STATE_UNBOUND, + TCP_SOCKET_STATE_BOUND, + TCP_SOCKET_STATE_CONNECTING, + TCP_SOCKET_STATE_CONNECTED, + TCP_SOCKET_STATE_CONNECT_FAILED, + TCP_SOCKET_STATE_LISTENING, + } tag; + union { + tcp_socket_state_unbound_t unbound; + tcp_socket_state_bound_t bound; + tcp_socket_state_connecting_t connecting; + tcp_socket_state_connected_t connected; + tcp_socket_state_connect_failed_t connect_failed; + tcp_socket_state_listening_t listening; + }; +} tcp_socket_state_t; + +typedef struct { + tcp_own_tcp_socket_t socket; + poll_own_pollable_t socket_pollable; + bool blocking; + bool fake_nodelay; + bool fake_reuseaddr; + network_ip_address_family_t family; + tcp_socket_state_t state; +} tcp_socket_t; + +typedef struct { + udp_own_incoming_datagram_stream_t incoming; + poll_own_pollable_t incoming_pollable; + udp_own_outgoing_datagram_stream_t outgoing; + poll_own_pollable_t outgoing_pollable; +} udp_socket_streams_t; + +typedef struct { + int dummy; +} udp_socket_state_unbound_t; +typedef struct { + int dummy; +} udp_socket_state_bound_nostreams_t; + +typedef struct { + udp_socket_streams_t streams; // Streams have no remote_address +} udp_socket_state_bound_streaming_t; + +typedef struct { + udp_socket_streams_t streams; // Streams have a remote_address +} udp_socket_state_connected_t; + +// This is a tagged union. When adding/removing/renaming cases, be sure to keep the tag and union definitions in sync. +// The "bound" state is split up into two distinct tags: +// - "bound_nostreams": Bound, but no datagram streams set up (yet). That will be done the first time send or recv is called. +// - "bound_streaming": Bound with active streams. +typedef struct { + enum { + UDP_SOCKET_STATE_UNBOUND, + UDP_SOCKET_STATE_BOUND_NOSTREAMS, + UDP_SOCKET_STATE_BOUND_STREAMING, + UDP_SOCKET_STATE_CONNECTED, + } tag; + union { + udp_socket_state_unbound_t unbound; + udp_socket_state_bound_nostreams_t bound_nostreams; + udp_socket_state_bound_streaming_t bound_streaming; + udp_socket_state_connected_t connected; + }; +} udp_socket_state_t; + +typedef struct { + udp_own_udp_socket_t socket; + poll_own_pollable_t socket_pollable; + bool blocking; + network_ip_address_family_t family; + udp_socket_state_t state; +} udp_socket_t; + +// This is a tagged union. When adding/removing/renaming cases, be sure to keep the tag and union definitions in sync. +typedef struct { + enum { + DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET, + DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET, + } tag; + union { + tcp_socket_t tcp_socket; + udp_socket_t udp_socket; + }; +} descriptor_table_entry_t; + +bool descriptor_table_insert(descriptor_table_entry_t entry, int *fd); + +bool descriptor_table_get_ref(int fd, descriptor_table_entry_t **entry); + +bool descriptor_table_remove(int fd, descriptor_table_entry_t *entry); + +#endif diff --git a/libc-bottom-half/headers/private/wasi/sockets_utils.h b/libc-bottom-half/headers/private/wasi/sockets_utils.h new file mode 100644 index 0000000..93cf1f4 --- /dev/null +++ b/libc-bottom-half/headers/private/wasi/sockets_utils.h @@ -0,0 +1,53 @@ +#ifndef __wasi_sockets_utils_h +#define __wasi_sockets_utils_h + +#include <netinet/in.h> + +#include <wasi/descriptor_table.h> + +typedef struct { + enum { + OUTPUT_SOCKADDR_NULL, + OUTPUT_SOCKADDR_V4, + OUTPUT_SOCKADDR_V6, + } tag; + union { + struct { + int dummy; + } null; + struct { + struct sockaddr_in *addr; + socklen_t *addrlen; + } v4; + struct { + struct sockaddr_in6 *addr; + socklen_t *addrlen; + } v6; + }; +} output_sockaddr_t; + +network_borrow_network_t __wasi_sockets_utils__borrow_network(); +int __wasi_sockets_utils__map_error(network_error_code_t wasi_error); +bool __wasi_sockets_utils__parse_address( + network_ip_address_family_t expected_family, + const struct sockaddr *address, socklen_t len, + network_ip_socket_address_t *result, int *error); +bool __wasi_sockets_utils__output_addr_validate( + network_ip_address_family_t expected_family, struct sockaddr *addr, + socklen_t *addrlen, output_sockaddr_t *result); +void __wasi_sockets_utils__output_addr_write( + const network_ip_socket_address_t input, output_sockaddr_t *output); +int __wasi_sockets_utils__posix_family(network_ip_address_family_t wasi_family); +network_ip_socket_address_t +__wasi_sockets_utils__any_addr(network_ip_address_family_t family); +int __wasi_sockets_utils__tcp_bind(tcp_socket_t *socket, + network_ip_socket_address_t *address); +int __wasi_sockets_utils__udp_bind(udp_socket_t *socket, + network_ip_socket_address_t *address); +bool __wasi_sockets_utils__stream(udp_socket_t *socket, + network_ip_socket_address_t *remote_address, + udp_socket_streams_t *result, + network_error_code_t *error); +void __wasi_sockets_utils__drop_streams(udp_socket_streams_t streams); + +#endif diff --git a/libc-bottom-half/headers/public/__errno.h b/libc-bottom-half/headers/public/__errno.h index 4fd983a..008245d 100644 --- a/libc-bottom-half/headers/public/__errno.h +++ b/libc-bottom-half/headers/public/__errno.h @@ -5,16 +5,11 @@ extern "C" { #endif -#ifdef __cplusplus -extern thread_local int errno; -#else extern _Thread_local int errno; -#endif #define errno errno #ifdef __cplusplus } #endif - #endif diff --git a/libc-bottom-half/headers/public/__header_dirent.h b/libc-bottom-half/headers/public/__header_dirent.h index ccf3def..027fc07 100644 --- a/libc-bottom-half/headers/public/__header_dirent.h +++ b/libc-bottom-half/headers/public/__header_dirent.h @@ -11,12 +11,16 @@ #define DT_REG __WASI_FILETYPE_REGULAR_FILE #define DT_UNKNOWN __WASI_FILETYPE_UNKNOWN +// DT_SOCK is not supported in WASI Preview 1 (but will be in Preview 2). We +// define it regardless so that libc++'s `<filesystem>` implementation builds. +// The exact value is mostly arbitrary, but chosen so it doesn't conflict with +// any of the existing `__WASI_FILETYPE_*` flags. We do not expect any new +// flags to be added to WASI Preview 1, so that should be sufficient. +#define DT_SOCK 20 + #define IFTODT(x) (__wasilibc_iftodt(x)) #define DTTOIF(x) (__wasilibc_dttoif(x)) -int __wasilibc_iftodt(int x); -int __wasilibc_dttoif(int x); - #include <__struct_dirent.h> #include <__typedef_DIR.h> @@ -24,6 +28,9 @@ int __wasilibc_dttoif(int x); extern "C" { #endif +int __wasilibc_iftodt(int x); +int __wasilibc_dttoif(int x); + int closedir(DIR *); DIR *opendir(const char *); DIR *fdopendir(int); diff --git a/libc-bottom-half/headers/public/__header_sys_socket.h b/libc-bottom-half/headers/public/__header_sys_socket.h index 8ba4eff..fa98cca 100644 --- a/libc-bottom-half/headers/public/__header_sys_socket.h +++ b/libc-bottom-half/headers/public/__header_sys_socket.h @@ -1,6 +1,7 @@ #ifndef __wasilibc___header_sys_socket_h #define __wasilibc___header_sys_socket_h +#include <__wasi_snapshot.h> #include <__struct_msghdr.h> #include <__struct_sockaddr.h> #include <__struct_sockaddr_storage.h> @@ -11,9 +12,42 @@ #define SHUT_WR __WASI_SDFLAGS_WR #define SHUT_RDWR (SHUT_RD | SHUT_WR) +#ifdef __wasilibc_use_wasip2 +#define MSG_DONTWAIT 0x0040 +#define MSG_NOSIGNAL 0x4000 +#define MSG_PEEK 0x0002 +#define MSG_WAITALL 0x0100 +#define MSG_TRUNC 0x0020 + +#define SOL_IP 0 +#define SOL_TCP 6 +#define SOL_UDP 17 +#define SOL_IPV6 41 + +#define SOMAXCONN 128 + +#define SO_REUSEADDR 2 +#define SO_ERROR 4 +#define SO_SNDBUF 7 +#define SO_RCVBUF 8 +#define SO_KEEPALIVE 9 +#define SO_ACCEPTCONN 30 +#define SO_PROTOCOL 38 +#define SO_DOMAIN 39 + +#if __LONG_MAX == 0x7fffffff +#define SO_RCVTIMEO 66 +#define SO_SNDTIMEO 67 +#else +#define SO_RCVTIMEO 20 +#define SO_SNDTIMEO 21 +#endif + +#else // __wasilibc_use_wasip2 #define MSG_PEEK __WASI_RIFLAGS_RECV_PEEK #define MSG_WAITALL __WASI_RIFLAGS_RECV_WAITALL #define MSG_TRUNC __WASI_ROFLAGS_RECV_DATA_TRUNCATED +#endif // __wasilibc_use_wasip2 #define SOCK_DGRAM __WASI_FILETYPE_SOCKET_DGRAM #define SOCK_STREAM __WASI_FILETYPE_SOCKET_STREAM diff --git a/libc-bottom-half/headers/public/__mode_t.h b/libc-bottom-half/headers/public/__mode_t.h index c0beef5..d2dbe04 100644 --- a/libc-bottom-half/headers/public/__mode_t.h +++ b/libc-bottom-half/headers/public/__mode_t.h @@ -9,7 +9,7 @@ #define S_IFLNK (0xa000) #define S_IFREG (0x8000) #define S_IFSOCK (0xc000) -#define S_IFIFO (0xc000) +#define S_IFIFO (0x1000) #define S_ISBLK(m) (((m)&S_IFMT) == S_IFBLK) #define S_ISCHR(m) (((m)&S_IFMT) == S_IFCHR) diff --git a/libc-bottom-half/headers/public/__wasi_snapshot.h b/libc-bottom-half/headers/public/__wasi_snapshot.h new file mode 100644 index 0000000..9a10078 --- /dev/null +++ b/libc-bottom-half/headers/public/__wasi_snapshot.h @@ -0,0 +1,5 @@ +/* This file is (practically) empty by default. The Makefile will replace it + with a non-empty version that defines `__wasilibc_use_wasip2` if targeting + `wasm32-wasip2`. + */ + diff --git a/libc-bottom-half/headers/public/wasi/wasip2.h b/libc-bottom-half/headers/public/wasi/wasip2.h new file mode 100644 index 0000000..49bb9b8 --- /dev/null +++ b/libc-bottom-half/headers/public/wasi/wasip2.h @@ -0,0 +1,2486 @@ +// Generated by `wit-bindgen` 0.17.0. DO NOT EDIT! +#ifndef __BINDINGS_WASIP2_H +#define __BINDINGS_WASIP2_H +#ifdef __cplusplus +extern "C" { +#endif + +#include <stdlib.h> +#include <string.h> +#include <stdint.h> +#include <stdbool.h> + +typedef struct { + uint8_t*ptr; + size_t len; +} wasip2_string_t; + +typedef struct { + wasip2_string_t f0; + wasip2_string_t f1; +} wasip2_tuple2_string_string_t; + +typedef struct { + wasip2_tuple2_string_string_t *ptr; + size_t len; +} wasip2_list_tuple2_string_string_t; + +typedef struct { + wasip2_string_t *ptr; + size_t len; +} wasip2_list_string_t; + +typedef struct { + bool is_some; + wasip2_string_t val; +} wasip2_option_string_t; + +typedef struct { + bool is_err; +} exit_result_void_void_t; + +typedef struct io_error_own_error_t { + int32_t __handle; +} io_error_own_error_t; + +typedef struct io_error_borrow_error_t { + int32_t __handle; +} io_error_borrow_error_t; + +typedef struct poll_own_pollable_t { + int32_t __handle; +} poll_own_pollable_t; + +typedef struct poll_borrow_pollable_t { + int32_t __handle; +} poll_borrow_pollable_t; + +typedef struct { + poll_borrow_pollable_t *ptr; + size_t len; +} poll_list_borrow_pollable_t; + +typedef struct { + uint32_t *ptr; + size_t len; +} wasip2_list_u32_t; + +typedef io_error_own_error_t streams_own_error_t; + +// An error for input-stream and output-stream operations. +typedef struct { + uint8_t tag; + union { + streams_own_error_t last_operation_failed; + } val; +} streams_stream_error_t; + +// The last operation (a write or flush) failed before completion. +// +// More information is available in the `error` payload. +#define STREAMS_STREAM_ERROR_LAST_OPERATION_FAILED 0 +// The stream is closed: no more input will be accepted by the +// stream. A closed output-stream will return this error on all +// future operations. +#define STREAMS_STREAM_ERROR_CLOSED 1 + +typedef struct streams_own_input_stream_t { + int32_t __handle; +} streams_own_input_stream_t; + +typedef struct streams_borrow_input_stream_t { + int32_t __handle; +} streams_borrow_input_stream_t; + +typedef struct streams_own_output_stream_t { + int32_t __handle; +} streams_own_output_stream_t; + +typedef struct streams_borrow_output_stream_t { + int32_t __handle; +} streams_borrow_output_stream_t; + +typedef struct { + uint8_t *ptr; + size_t len; +} wasip2_list_u8_t; + +typedef struct { + bool is_err; + union { + wasip2_list_u8_t ok; + streams_stream_error_t err; + } val; +} streams_result_list_u8_stream_error_t; + +typedef struct { + bool is_err; + union { + uint64_t ok; + streams_stream_error_t err; + } val; +} streams_result_u64_stream_error_t; + +typedef poll_own_pollable_t streams_own_pollable_t; + +typedef struct { + bool is_err; + union { + streams_stream_error_t err; + } val; +} streams_result_void_stream_error_t; + +typedef streams_own_input_stream_t stdin_own_input_stream_t; + +typedef streams_own_output_stream_t stdout_own_output_stream_t; + +typedef streams_own_output_stream_t stderr_own_output_stream_t; + +typedef struct terminal_input_own_terminal_input_t { + int32_t __handle; +} terminal_input_own_terminal_input_t; + +typedef struct terminal_input_borrow_terminal_input_t { + int32_t __handle; +} terminal_input_borrow_terminal_input_t; + +typedef struct terminal_output_own_terminal_output_t { + int32_t __handle; +} terminal_output_own_terminal_output_t; + +typedef struct terminal_output_borrow_terminal_output_t { + int32_t __handle; +} terminal_output_borrow_terminal_output_t; + +typedef terminal_input_own_terminal_input_t terminal_stdin_own_terminal_input_t; + +typedef struct { + bool is_some; + terminal_stdin_own_terminal_input_t val; +} terminal_stdin_option_own_terminal_input_t; + +typedef terminal_output_own_terminal_output_t terminal_stdout_own_terminal_output_t; + +typedef struct { + bool is_some; + terminal_stdout_own_terminal_output_t val; +} terminal_stdout_option_own_terminal_output_t; + +typedef terminal_output_own_terminal_output_t terminal_stderr_own_terminal_output_t; + +typedef struct { + bool is_some; + terminal_stderr_own_terminal_output_t val; +} terminal_stderr_option_own_terminal_output_t; + +// An instant in time, in nanoseconds. An instant is relative to an +// unspecified initial value, and can only be compared to instances from +// the same monotonic-clock. +typedef uint64_t monotonic_clock_instant_t; + +// A duration of time, in nanoseconds. +typedef uint64_t monotonic_clock_duration_t; + +typedef poll_own_pollable_t monotonic_clock_own_pollable_t; + +// A time and date in seconds plus nanoseconds. +typedef struct { + uint64_t seconds; + uint32_t nanoseconds; +} wall_clock_datetime_t; + +typedef wall_clock_datetime_t filesystem_datetime_t; + +// File size or length of a region within a file. +typedef uint64_t filesystem_filesize_t; + +// The type of a filesystem object referenced by a descriptor. +// +// Note: This was called `filetype` in earlier versions of WASI. +typedef uint8_t filesystem_descriptor_type_t; + +// The type of the descriptor or file is unknown or is different from +// any of the other types specified. +#define FILESYSTEM_DESCRIPTOR_TYPE_UNKNOWN 0 +// The descriptor refers to a block device inode. +#define FILESYSTEM_DESCRIPTOR_TYPE_BLOCK_DEVICE 1 +// The descriptor refers to a character device inode. +#define FILESYSTEM_DESCRIPTOR_TYPE_CHARACTER_DEVICE 2 +// The descriptor refers to a directory inode. +#define FILESYSTEM_DESCRIPTOR_TYPE_DIRECTORY 3 +// The descriptor refers to a named pipe. +#define FILESYSTEM_DESCRIPTOR_TYPE_FIFO 4 +// The file refers to a symbolic link inode. +#define FILESYSTEM_DESCRIPTOR_TYPE_SYMBOLIC_LINK 5 +// The descriptor refers to a regular file inode. +#define FILESYSTEM_DESCRIPTOR_TYPE_REGULAR_FILE 6 +// The descriptor refers to a socket. +#define FILESYSTEM_DESCRIPTOR_TYPE_SOCKET 7 + +// Descriptor flags. +// +// Note: This was called `fdflags` in earlier versions of WASI. +typedef uint8_t filesystem_descriptor_flags_t; + +// Read mode: Data can be read. +#define FILESYSTEM_DESCRIPTOR_FLAGS_READ (1 << 0) +// Write mode: Data can be written to. +#define FILESYSTEM_DESCRIPTOR_FLAGS_WRITE (1 << 1) +// Request that writes be performed according to synchronized I/O file +// integrity completion. The data stored in the file and the file's +// metadata are synchronized. This is similar to `O_SYNC` in POSIX. +// +// The precise semantics of this operation have not yet been defined for +// WASI. At this time, it should be interpreted as a request, and not a +// requirement. +#define FILESYSTEM_DESCRIPTOR_FLAGS_FILE_INTEGRITY_SYNC (1 << 2) +// Request that writes be performed according to synchronized I/O data +// integrity completion. Only the data stored in the file is +// synchronized. This is similar to `O_DSYNC` in POSIX. +// +// The precise semantics of this operation have not yet been defined for +// WASI. At this time, it should be interpreted as a request, and not a +// requirement. +#define FILESYSTEM_DESCRIPTOR_FLAGS_DATA_INTEGRITY_SYNC (1 << 3) +// Requests that reads be performed at the same level of integrety +// requested for writes. This is similar to `O_RSYNC` in POSIX. +// +// The precise semantics of this operation have not yet been defined for +// WASI. At this time, it should be interpreted as a request, and not a +// requirement. +#define FILESYSTEM_DESCRIPTOR_FLAGS_REQUESTED_WRITE_SYNC (1 << 4) +// Mutating directories mode: Directory contents may be mutated. +// +// When this flag is unset on a descriptor, operations using the +// descriptor which would create, rename, delete, modify the data or +// metadata of filesystem objects, or obtain another handle which +// would permit any of those, shall fail with `error-code::read-only` if +// they would otherwise succeed. +// +// This may only be set on directories. +#define FILESYSTEM_DESCRIPTOR_FLAGS_MUTATE_DIRECTORY (1 << 5) + +// Flags determining the method of how paths are resolved. +typedef uint8_t filesystem_path_flags_t; + +// As long as the resolved path corresponds to a symbolic link, it is +// expanded. +#define FILESYSTEM_PATH_FLAGS_SYMLINK_FOLLOW (1 << 0) + +// Open flags used by `open-at`. +typedef uint8_t filesystem_open_flags_t; + +// Create file if it does not exist, similar to `O_CREAT` in POSIX. +#define FILESYSTEM_OPEN_FLAGS_CREATE (1 << 0) +// Fail if not a directory, similar to `O_DIRECTORY` in POSIX. +#define FILESYSTEM_OPEN_FLAGS_DIRECTORY (1 << 1) +// Fail if file already exists, similar to `O_EXCL` in POSIX. +#define FILESYSTEM_OPEN_FLAGS_EXCLUSIVE (1 << 2) +// Truncate file to size 0, similar to `O_TRUNC` in POSIX. +#define FILESYSTEM_OPEN_FLAGS_TRUNCATE (1 << 3) + +// Number of hard links to an inode. +typedef uint64_t filesystem_link_count_t; + +typedef struct { + bool is_some; + filesystem_datetime_t val; +} filesystem_option_datetime_t; + +// File attributes. +// +// Note: This was called `filestat` in earlier versions of WASI. +typedef struct { + // File type. + filesystem_descriptor_type_t type; + // Number of hard links to the file. + filesystem_link_count_t link_count; + // For regular files, the file size in bytes. For symbolic links, the + // length in bytes of the pathname contained in the symbolic link. + filesystem_filesize_t size; + // Last data access timestamp. + // + // If the `option` is none, the platform doesn't maintain an access + // timestamp for this file. + filesystem_option_datetime_t data_access_timestamp; + // Last data modification timestamp. + // + // If the `option` is none, the platform doesn't maintain a + // modification timestamp for this file. + filesystem_option_datetime_t data_modification_timestamp; + // Last file status-change timestamp. + // + // If the `option` is none, the platform doesn't maintain a + // status-change timestamp for this file. + filesystem_option_datetime_t status_change_timestamp; +} filesystem_descriptor_stat_t; + +// When setting a timestamp, this gives the value to set it to. +typedef struct { + uint8_t tag; + union { + filesystem_datetime_t timestamp; + } val; +} filesystem_new_timestamp_t; + +// Leave the timestamp set to its previous value. +#define FILESYSTEM_NEW_TIMESTAMP_NO_CHANGE 0 +// Set the timestamp to the current time of the system clock associated +// with the filesystem. +#define FILESYSTEM_NEW_TIMESTAMP_NOW 1 +// Set the timestamp to the given value. +#define FILESYSTEM_NEW_TIMESTAMP_TIMESTAMP 2 + +// A directory entry. +typedef struct { + // The type of the file referred to by this directory entry. + filesystem_descriptor_type_t type; + // The name of the object. + wasip2_string_t name; +} filesystem_directory_entry_t; + +// Error codes returned by functions, similar to `errno` in POSIX. +// Not all of these error codes are returned by the functions provided by this +// API; some are used in higher-level library layers, and others are provided +// merely for alignment with POSIX. +typedef uint8_t filesystem_error_code_t; + +// Permission denied, similar to `EACCES` in POSIX. +#define FILESYSTEM_ERROR_CODE_ACCESS 0 +// Resource unavailable, or operation would block, similar to `EAGAIN` and `EWOULDBLOCK` in POSIX. +#define FILESYSTEM_ERROR_CODE_WOULD_BLOCK 1 +// Connection already in progress, similar to `EALREADY` in POSIX. +#define FILESYSTEM_ERROR_CODE_ALREADY 2 +// Bad descriptor, similar to `EBADF` in POSIX. +#define FILESYSTEM_ERROR_CODE_BAD_DESCRIPTOR 3 +// Device or resource busy, similar to `EBUSY` in POSIX. +#define FILESYSTEM_ERROR_CODE_BUSY 4 +// Resource deadlock would occur, similar to `EDEADLK` in POSIX. +#define FILESYSTEM_ERROR_CODE_DEADLOCK 5 +// Storage quota exceeded, similar to `EDQUOT` in POSIX. +#define FILESYSTEM_ERROR_CODE_QUOTA 6 +// File exists, similar to `EEXIST` in POSIX. +#define FILESYSTEM_ERROR_CODE_EXIST 7 +// File too large, similar to `EFBIG` in POSIX. +#define FILESYSTEM_ERROR_CODE_FILE_TOO_LARGE 8 +// Illegal byte sequence, similar to `EILSEQ` in POSIX. +#define FILESYSTEM_ERROR_CODE_ILLEGAL_BYTE_SEQUENCE 9 +// Operation in progress, similar to `EINPROGRESS` in POSIX. +#define FILESYSTEM_ERROR_CODE_IN_PROGRESS 10 +// Interrupted function, similar to `EINTR` in POSIX. +#define FILESYSTEM_ERROR_CODE_INTERRUPTED 11 +// Invalid argument, similar to `EINVAL` in POSIX. +#define FILESYSTEM_ERROR_CODE_INVALID 12 +// I/O error, similar to `EIO` in POSIX. +#define FILESYSTEM_ERROR_CODE_IO 13 +// Is a directory, similar to `EISDIR` in POSIX. +#define FILESYSTEM_ERROR_CODE_IS_DIRECTORY 14 +// Too many levels of symbolic links, similar to `ELOOP` in POSIX. +#define FILESYSTEM_ERROR_CODE_LOOP 15 +// Too many links, similar to `EMLINK` in POSIX. +#define FILESYSTEM_ERROR_CODE_TOO_MANY_LINKS 16 +// Message too large, similar to `EMSGSIZE` in POSIX. +#define FILESYSTEM_ERROR_CODE_MESSAGE_SIZE 17 +// Filename too long, similar to `ENAMETOOLONG` in POSIX. +#define FILESYSTEM_ERROR_CODE_NAME_TOO_LONG 18 +// No such device, similar to `ENODEV` in POSIX. +#define FILESYSTEM_ERROR_CODE_NO_DEVICE 19 +// No such file or directory, similar to `ENOENT` in POSIX. +#define FILESYSTEM_ERROR_CODE_NO_ENTRY 20 +// No locks available, similar to `ENOLCK` in POSIX. +#define FILESYSTEM_ERROR_CODE_NO_LOCK 21 +// Not enough space, similar to `ENOMEM` in POSIX. +#define FILESYSTEM_ERROR_CODE_INSUFFICIENT_MEMORY 22 +// No space left on device, similar to `ENOSPC` in POSIX. +#define FILESYSTEM_ERROR_CODE_INSUFFICIENT_SPACE 23 +// Not a directory or a symbolic link to a directory, similar to `ENOTDIR` in POSIX. +#define FILESYSTEM_ERROR_CODE_NOT_DIRECTORY 24 +// Directory not empty, similar to `ENOTEMPTY` in POSIX. +#define FILESYSTEM_ERROR_CODE_NOT_EMPTY 25 +// State not recoverable, similar to `ENOTRECOVERABLE` in POSIX. +#define FILESYSTEM_ERROR_CODE_NOT_RECOVERABLE 26 +// Not supported, similar to `ENOTSUP` and `ENOSYS` in POSIX. +#define FILESYSTEM_ERROR_CODE_UNSUPPORTED 27 +// Inappropriate I/O control operation, similar to `ENOTTY` in POSIX. +#define FILESYSTEM_ERROR_CODE_NO_TTY 28 +// No such device or address, similar to `ENXIO` in POSIX. +#define FILESYSTEM_ERROR_CODE_NO_SUCH_DEVICE 29 +// Value too large to be stored in data type, similar to `EOVERFLOW` in POSIX. +#define FILESYSTEM_ERROR_CODE_OVERFLOW 30 +// Operation not permitted, similar to `EPERM` in POSIX. +#define FILESYSTEM_ERROR_CODE_NOT_PERMITTED 31 +// Broken pipe, similar to `EPIPE` in POSIX. +#define FILESYSTEM_ERROR_CODE_PIPE 32 +// Read-only file system, similar to `EROFS` in POSIX. +#define FILESYSTEM_ERROR_CODE_READ_ONLY 33 +// Invalid seek, similar to `ESPIPE` in POSIX. +#define FILESYSTEM_ERROR_CODE_INVALID_SEEK 34 +// Text file busy, similar to `ETXTBSY` in POSIX. +#define FILESYSTEM_ERROR_CODE_TEXT_FILE_BUSY 35 +// Cross-device link, similar to `EXDEV` in POSIX. +#define FILESYSTEM_ERROR_CODE_CROSS_DEVICE 36 + +// File or memory access pattern advisory information. +typedef uint8_t filesystem_advice_t; + +// The application has no advice to give on its behavior with respect +// to the specified data. +#define FILESYSTEM_ADVICE_NORMAL 0 +// The application expects to access the specified data sequentially +// from lower offsets to higher offsets. +#define FILESYSTEM_ADVICE_SEQUENTIAL 1 +// The application expects to access the specified data in a random +// order. +#define FILESYSTEM_ADVICE_RANDOM 2 +// The application expects to access the specified data in the near +// future. +#define FILESYSTEM_ADVICE_WILL_NEED 3 +// The application expects that it will not access the specified data +// in the near future. +#define FILESYSTEM_ADVICE_DONT_NEED 4 +// The application expects to access the specified data once and then +// not reuse it thereafter. +#define FILESYSTEM_ADVICE_NO_REUSE 5 + +// A 128-bit hash value, split into parts because wasm doesn't have a +// 128-bit integer type. +typedef struct { + // 64 bits of a 128-bit hash value. + uint64_t lower; + // Another 64 bits of a 128-bit hash value. + uint64_t upper; +} filesystem_metadata_hash_value_t; + +typedef struct filesystem_own_descriptor_t { + int32_t __handle; +} filesystem_own_descriptor_t; + +typedef struct filesystem_borrow_descriptor_t { + int32_t __handle; +} filesystem_borrow_descriptor_t; + +typedef struct filesystem_own_directory_entry_stream_t { + int32_t __handle; +} filesystem_own_directory_entry_stream_t; + +typedef struct filesystem_borrow_directory_entry_stream_t { + int32_t __handle; +} filesystem_borrow_directory_entry_stream_t; + +typedef streams_own_input_stream_t filesystem_own_input_stream_t; + +typedef struct { + bool is_err; + union { + filesystem_own_input_stream_t ok; + filesystem_error_code_t err; + } val; +} filesystem_result_own_input_stream_error_code_t; + +typedef streams_own_output_stream_t filesystem_own_output_stream_t; + +typedef struct { + bool is_err; + union { + filesystem_own_output_stream_t ok; + filesystem_error_code_t err; + } val; +} filesystem_result_own_output_stream_error_code_t; + +typedef struct { + bool is_err; + union { + filesystem_error_code_t err; + } val; +} filesystem_result_void_error_code_t; + +typedef struct { + bool is_err; + union { + filesystem_descriptor_flags_t ok; + filesystem_error_code_t err; + } val; +} filesystem_result_descriptor_flags_error_code_t; + +typedef struct { + bool is_err; + union { + filesystem_descriptor_type_t ok; + filesystem_error_code_t err; + } val; +} filesystem_result_descriptor_type_error_code_t; + +typedef struct { + wasip2_list_u8_t f0; + bool f1; +} wasip2_tuple2_list_u8_bool_t; + +typedef struct { + bool is_err; + union { + wasip2_tuple2_list_u8_bool_t ok; + filesystem_error_code_t err; + } val; +} filesystem_result_tuple2_list_u8_bool_error_code_t; + +typedef struct { + bool is_err; + union { + filesystem_filesize_t ok; + filesystem_error_code_t err; + } val; +} filesystem_result_filesize_error_code_t; + +typedef struct { + bool is_err; + union { + filesystem_own_directory_entry_stream_t ok; + filesystem_error_code_t err; + } val; +} filesystem_result_own_directory_entry_stream_error_code_t; + +typedef struct { + bool is_err; + union { + filesystem_descriptor_stat_t ok; + filesystem_error_code_t err; + } val; +} filesystem_result_descriptor_stat_error_code_t; + +typedef struct { + bool is_err; + union { + filesystem_own_descriptor_t ok; + filesystem_error_code_t err; + } val; +} filesystem_result_own_descriptor_error_code_t; + +typedef struct { + bool is_err; + union { + wasip2_string_t ok; + filesystem_error_code_t err; + } val; +} filesystem_result_string_error_code_t; + +typedef struct { + bool is_err; + union { + filesystem_metadata_hash_value_t ok; + filesystem_error_code_t err; + } val; +} filesystem_result_metadata_hash_value_error_code_t; + +typedef struct { + bool is_some; + filesystem_directory_entry_t val; +} filesystem_option_directory_entry_t; + +typedef struct { + bool is_err; + union { + filesystem_option_directory_entry_t ok; + filesystem_error_code_t err; + } val; +} filesystem_result_option_directory_entry_error_code_t; + +typedef io_error_borrow_error_t filesystem_borrow_error_t; + +typedef struct { + bool is_some; + filesystem_error_code_t val; +} filesystem_option_error_code_t; + +typedef filesystem_own_descriptor_t filesystem_preopens_own_descriptor_t; + +typedef struct { + filesystem_preopens_own_descriptor_t f0; + wasip2_string_t f1; +} filesystem_preopens_tuple2_own_descriptor_string_t; + +typedef struct { + filesystem_preopens_tuple2_own_descriptor_string_t *ptr; + size_t len; +} filesystem_preopens_list_tuple2_own_descriptor_string_t; + +typedef struct network_own_network_t { + int32_t __handle; +} network_own_network_t; + +typedef struct network_borrow_network_t { + int32_t __handle; +} network_borrow_network_t; + +// Error codes. +// +// In theory, every API can return any error code. +// In practice, API's typically only return the errors documented per API +// combined with a couple of errors that are always possible: +// - `unknown` +// - `access-denied` +// - `not-supported` +// - `out-of-memory` +// - `concurrency-conflict` +// +// See each individual API for what the POSIX equivalents are. They sometimes differ per API. +typedef uint8_t network_error_code_t; + +// Unknown error +#define NETWORK_ERROR_CODE_UNKNOWN 0 +// Access denied. +// +// POSIX equivalent: EACCES, EPERM +#define NETWORK_ERROR_CODE_ACCESS_DENIED 1 +// The operation is not supported. +// +// POSIX equivalent: EOPNOTSUPP +#define NETWORK_ERROR_CODE_NOT_SUPPORTED 2 +// One of the arguments is invalid. +// +// POSIX equivalent: EINVAL +#define NETWORK_ERROR_CODE_INVALID_ARGUMENT 3 +// Not enough memory to complete the operation. +// +// POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY +#define NETWORK_ERROR_CODE_OUT_OF_MEMORY 4 +// The operation timed out before it could finish completely. +#define NETWORK_ERROR_CODE_TIMEOUT 5 +// This operation is incompatible with another asynchronous operation that is already in progress. +// +// POSIX equivalent: EALREADY +#define NETWORK_ERROR_CODE_CONCURRENCY_CONFLICT 6 +// Trying to finish an asynchronous operation that: +// - has not been started yet, or: +// - was already finished by a previous `finish-*` call. +// +// Note: this is scheduled to be removed when `future`s are natively supported. +#define NETWORK_ERROR_CODE_NOT_IN_PROGRESS 7 +// The operation has been aborted because it could not be completed immediately. +// +// Note: this is scheduled to be removed when `future`s are natively supported. +#define NETWORK_ERROR_CODE_WOULD_BLOCK 8 +// The operation is not valid in the socket's current state. +#define NETWORK_ERROR_CODE_INVALID_STATE 9 +// A new socket resource could not be created because of a system limit. +#define NETWORK_ERROR_CODE_NEW_SOCKET_LIMIT 10 +// A bind operation failed because the provided address is not an address that the `network` can bind to. +#define NETWORK_ERROR_CODE_ADDRESS_NOT_BINDABLE 11 +// A bind operation failed because the provided address is already in use or because there are no ephemeral ports available. +#define NETWORK_ERROR_CODE_ADDRESS_IN_USE 12 +// The remote address is not reachable +#define NETWORK_ERROR_CODE_REMOTE_UNREACHABLE 13 +// The TCP connection was forcefully rejected +#define NETWORK_ERROR_CODE_CONNECTION_REFUSED 14 +// The TCP connection was reset. +#define NETWORK_ERROR_CODE_CONNECTION_RESET 15 +// A TCP connection was aborted. +#define NETWORK_ERROR_CODE_CONNECTION_ABORTED 16 +// The size of a datagram sent to a UDP socket exceeded the maximum +// supported size. +#define NETWORK_ERROR_CODE_DATAGRAM_TOO_LARGE 17 +// Name does not exist or has no suitable associated IP addresses. +#define NETWORK_ERROR_CODE_NAME_UNRESOLVABLE 18 +// A temporary failure in name resolution occurred. +#define NETWORK_ERROR_CODE_TEMPORARY_RESOLVER_FAILURE 19 +// A permanent failure in name resolution occurred. +#define NETWORK_ERROR_CODE_PERMANENT_RESOLVER_FAILURE 20 + +typedef uint8_t network_ip_address_family_t; + +// Similar to `AF_INET` in POSIX. +#define NETWORK_IP_ADDRESS_FAMILY_IPV4 0 +// Similar to `AF_INET6` in POSIX. +#define NETWORK_IP_ADDRESS_FAMILY_IPV6 1 + +typedef struct { + uint8_t f0; + uint8_t f1; + uint8_t f2; + uint8_t f3; +} network_ipv4_address_t; + +typedef struct { + uint16_t f0; + uint16_t f1; + uint16_t f2; + uint16_t f3; + uint16_t f4; + uint16_t f5; + uint16_t f6; + uint16_t f7; +} network_ipv6_address_t; + +typedef struct { + uint8_t tag; + union { + network_ipv4_address_t ipv4; + network_ipv6_address_t ipv6; + } val; +} network_ip_address_t; + +#define NETWORK_IP_ADDRESS_IPV4 0 +#define NETWORK_IP_ADDRESS_IPV6 1 + +typedef struct { + // sin_port + uint16_t port; + // sin_addr + network_ipv4_address_t address; +} network_ipv4_socket_address_t; + +typedef struct { + // sin6_port + uint16_t port; + // sin6_flowinfo + uint32_t flow_info; + // sin6_addr + network_ipv6_address_t address; + // sin6_scope_id + uint32_t scope_id; +} network_ipv6_socket_address_t; + +typedef struct { + uint8_t tag; + union { + network_ipv4_socket_address_t ipv4; + network_ipv6_socket_address_t ipv6; + } val; +} network_ip_socket_address_t; + +#define NETWORK_IP_SOCKET_ADDRESS_IPV4 0 +#define NETWORK_IP_SOCKET_ADDRESS_IPV6 1 + +typedef network_own_network_t instance_network_own_network_t; + +typedef network_error_code_t udp_error_code_t; + +typedef network_ip_socket_address_t udp_ip_socket_address_t; + +typedef network_ip_address_family_t udp_ip_address_family_t; + +// A received datagram. +typedef struct { + // The payload. + // + // Theoretical max size: ~64 KiB. In practice, typically less than 1500 bytes. + wasip2_list_u8_t data; + // The source address. + // + // This field is guaranteed to match the remote address the stream was initialized with, if any. + // + // Equivalent to the `src_addr` out parameter of `recvfrom`. + udp_ip_socket_address_t remote_address; +} udp_incoming_datagram_t; + +typedef struct { + bool is_some; + udp_ip_socket_address_t val; +} udp_option_ip_socket_address_t; + +// A datagram to be sent out. +typedef struct { + // The payload. + wasip2_list_u8_t data; + // The destination address. + // + // The requirements on this field depend on how the stream was initialized: + // - with a remote address: this field must be None or match the stream's remote address exactly. + // - without a remote address: this field is required. + // + // If this value is None, the send operation is equivalent to `send` in POSIX. Otherwise it is equivalent to `sendto`. + udp_option_ip_socket_address_t remote_address; +} udp_outgoing_datagram_t; + +typedef struct udp_own_udp_socket_t { + int32_t __handle; +} udp_own_udp_socket_t; + +typedef struct udp_borrow_udp_socket_t { + int32_t __handle; +} udp_borrow_udp_socket_t; + +typedef struct udp_own_incoming_datagram_stream_t { + int32_t __handle; +} udp_own_incoming_datagram_stream_t; + +typedef struct udp_borrow_incoming_datagram_stream_t { + int32_t __handle; +} udp_borrow_incoming_datagram_stream_t; + +typedef struct udp_own_outgoing_datagram_stream_t { + int32_t __handle; +} udp_own_outgoing_datagram_stream_t; + +typedef struct udp_borrow_outgoing_datagram_stream_t { + int32_t __handle; +} udp_borrow_outgoing_datagram_stream_t; + +typedef network_borrow_network_t udp_borrow_network_t; + +typedef struct { + bool is_err; + union { + udp_error_code_t err; + } val; +} udp_result_void_error_code_t; + +typedef struct { + udp_own_incoming_datagram_stream_t f0; + udp_own_outgoing_datagram_stream_t f1; +} udp_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_t; + +typedef struct { + bool is_err; + union { + udp_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_t ok; + udp_error_code_t err; + } val; +} udp_result_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_error_code_t; + +typedef struct { + bool is_err; + union { + udp_ip_socket_address_t ok; + udp_error_code_t err; + } val; +} udp_result_ip_socket_address_error_code_t; + +typedef struct { + bool is_err; + union { + uint8_t ok; + udp_error_code_t err; + } val; +} udp_result_u8_error_code_t; + +typedef struct { + bool is_err; + union { + uint64_t ok; + udp_error_code_t err; + } val; +} udp_result_u64_error_code_t; + +typedef poll_own_pollable_t udp_own_pollable_t; + +typedef struct { + udp_incoming_datagram_t *ptr; + size_t len; +} udp_list_incoming_datagram_t; + +typedef struct { + bool is_err; + union { + udp_list_incoming_datagram_t ok; + udp_error_code_t err; + } val; +} udp_result_list_incoming_datagram_error_code_t; + +typedef struct { + udp_outgoing_datagram_t *ptr; + size_t len; +} udp_list_outgoing_datagram_t; + +typedef network_error_code_t udp_create_socket_error_code_t; + +typedef network_ip_address_family_t udp_create_socket_ip_address_family_t; + +typedef udp_own_udp_socket_t udp_create_socket_own_udp_socket_t; + +typedef struct { + bool is_err; + union { + udp_create_socket_own_udp_socket_t ok; + udp_create_socket_error_code_t err; + } val; +} udp_create_socket_result_own_udp_socket_error_code_t; + +typedef monotonic_clock_duration_t tcp_duration_t; + +typedef network_error_code_t tcp_error_code_t; + +typedef network_ip_socket_address_t tcp_ip_socket_address_t; + +typedef network_ip_address_family_t tcp_ip_address_family_t; + +typedef uint8_t tcp_shutdown_type_t; + +// Similar to `SHUT_RD` in POSIX. +#define TCP_SHUTDOWN_TYPE_RECEIVE 0 +// Similar to `SHUT_WR` in POSIX. +#define TCP_SHUTDOWN_TYPE_SEND 1 +// Similar to `SHUT_RDWR` in POSIX. +#define TCP_SHUTDOWN_TYPE_BOTH 2 + +typedef struct tcp_own_tcp_socket_t { + int32_t __handle; +} tcp_own_tcp_socket_t; + +typedef struct tcp_borrow_tcp_socket_t { + int32_t __handle; +} tcp_borrow_tcp_socket_t; + +typedef network_borrow_network_t tcp_borrow_network_t; + +typedef struct { + bool is_err; + union { + tcp_error_code_t err; + } val; +} tcp_result_void_error_code_t; + +typedef streams_own_input_stream_t tcp_own_input_stream_t; + +typedef streams_own_output_stream_t tcp_own_output_stream_t; + +typedef struct { + tcp_own_input_stream_t f0; + tcp_own_output_stream_t f1; +} tcp_tuple2_own_input_stream_own_output_stream_t; + +typedef struct { + bool is_err; + union { + tcp_tuple2_own_input_stream_own_output_stream_t ok; + tcp_error_code_t err; + } val; +} tcp_result_tuple2_own_input_stream_own_output_stream_error_code_t; + +typedef struct { + tcp_own_tcp_socket_t f0; + tcp_own_input_stream_t f1; + tcp_own_output_stream_t f2; +} tcp_tuple3_own_tcp_socket_own_input_stream_own_output_stream_t; + +typedef struct { + bool is_err; + union { + tcp_tuple3_own_tcp_socket_own_input_stream_own_output_stream_t ok; + tcp_error_code_t err; + } val; +} tcp_result_tuple3_own_tcp_socket_own_input_stream_own_output_stream_error_code_t; + +typedef struct { + bool is_err; + union { + tcp_ip_socket_address_t ok; + tcp_error_code_t err; + } val; +} tcp_result_ip_socket_address_error_code_t; + +typedef struct { + bool is_err; + union { + bool ok; + tcp_error_code_t err; + } val; +} tcp_result_bool_error_code_t; + +typedef struct { + bool is_err; + union { + tcp_duration_t ok; + tcp_error_code_t err; + } val; +} tcp_result_duration_error_code_t; + +typedef struct { + bool is_err; + union { + uint32_t ok; + tcp_error_code_t err; + } val; +} tcp_result_u32_error_code_t; + +typedef struct { + bool is_err; + union { + uint8_t ok; + tcp_error_code_t err; + } val; +} tcp_result_u8_error_code_t; + +typedef struct { + bool is_err; + union { + uint64_t ok; + tcp_error_code_t err; + } val; +} tcp_result_u64_error_code_t; + +typedef poll_own_pollable_t tcp_own_pollable_t; + +typedef network_error_code_t tcp_create_socket_error_code_t; + +typedef network_ip_address_family_t tcp_create_socket_ip_address_family_t; + +typedef tcp_own_tcp_socket_t tcp_create_socket_own_tcp_socket_t; + +typedef struct { + bool is_err; + union { + tcp_create_socket_own_tcp_socket_t ok; + tcp_create_socket_error_code_t err; + } val; +} tcp_create_socket_result_own_tcp_socket_error_code_t; + +typedef network_error_code_t ip_name_lookup_error_code_t; + +typedef network_ip_address_t ip_name_lookup_ip_address_t; + +typedef struct ip_name_lookup_own_resolve_address_stream_t { + int32_t __handle; +} ip_name_lookup_own_resolve_address_stream_t; + +typedef struct ip_name_lookup_borrow_resolve_address_stream_t { + int32_t __handle; +} ip_name_lookup_borrow_resolve_address_stream_t; + +typedef network_borrow_network_t ip_name_lookup_borrow_network_t; + +typedef struct { + bool is_err; + union { + ip_name_lookup_own_resolve_address_stream_t ok; + ip_name_lookup_error_code_t err; + } val; +} ip_name_lookup_result_own_resolve_address_stream_error_code_t; + +typedef struct { + bool is_some; + ip_name_lookup_ip_address_t val; +} ip_name_lookup_option_ip_address_t; + +typedef struct { + bool is_err; + union { + ip_name_lookup_option_ip_address_t ok; + ip_name_lookup_error_code_t err; + } val; +} ip_name_lookup_result_option_ip_address_error_code_t; + +typedef poll_own_pollable_t ip_name_lookup_own_pollable_t; + +typedef struct { + uint64_t f0; + uint64_t f1; +} wasip2_tuple2_u64_u64_t; + +// Imported Functions from `wasi:cli/environment@0.2.0` +// Get the POSIX-style environment variables. +// +// Each environment variable is provided as a pair of string variable names +// and string value. +// +// Morally, these are a value import, but until value imports are available +// in the component model, this import function should return the same +// values each time it is called. +extern void environment_get_environment(wasip2_list_tuple2_string_string_t *ret); +// Get the POSIX-style arguments to the program. +extern void environment_get_arguments(wasip2_list_string_t *ret); +// Return a path that programs should use as their initial current working +// directory, interpreting `.` as shorthand for this. +extern bool environment_initial_cwd(wasip2_string_t *ret); + +// Imported Functions from `wasi:cli/exit@0.2.0` +// Exit the current instance and any linked instances. +extern void exit_exit(exit_result_void_void_t *status); + +// Imported Functions from `wasi:io/error@0.2.0` +// Returns a string that is suitable to assist humans in debugging +// this error. +// +// WARNING: The returned string should not be consumed mechanically! +// It may change across platforms, hosts, or other implementation +// details. Parsing this string is a major platform-compatibility +// hazard. +extern void io_error_method_error_to_debug_string(io_error_borrow_error_t self, wasip2_string_t *ret); + +// Imported Functions from `wasi:io/poll@0.2.0` +// Return the readiness of a pollable. This function never blocks. +// +// Returns `true` when the pollable is ready, and `false` otherwise. +extern bool poll_method_pollable_ready(poll_borrow_pollable_t self); +// `block` returns immediately if the pollable is ready, and otherwise +// blocks until ready. +// +// This function is equivalent to calling `poll.poll` on a list +// containing only this pollable. +extern void poll_method_pollable_block(poll_borrow_pollable_t self); +// Poll for completion on a set of pollables. +// +// This function takes a list of pollables, which identify I/O sources of +// interest, and waits until one or more of the events is ready for I/O. +// +// The result `list<u32>` contains one or more indices of handles in the +// argument list that is ready for I/O. +// +// If the list contains more elements than can be indexed with a `u32` +// value, this function traps. +// +// A timeout can be implemented by adding a pollable from the +// wasi-clocks API to the list. +// +// This function does not return a `result`; polling in itself does not +// do any I/O so it doesn't fail. If any of the I/O sources identified by +// the pollables has an error, it is indicated by marking the source as +// being reaedy for I/O. +extern void poll_poll(poll_list_borrow_pollable_t *in, wasip2_list_u32_t *ret); + +// Imported Functions from `wasi:io/streams@0.2.0` +// Perform a non-blocking read from the stream. +// +// When the source of a `read` is binary data, the bytes from the source +// are returned verbatim. When the source of a `read` is known to the +// implementation to be text, bytes containing the UTF-8 encoding of the +// text are returned. +// +// This function returns a list of bytes containing the read data, +// when successful. The returned list will contain up to `len` bytes; +// it may return fewer than requested, but not more. The list is +// empty when no bytes are available for reading at this time. The +// pollable given by `subscribe` will be ready when more bytes are +// available. +// +// This function fails with a `stream-error` when the operation +// encounters an error, giving `last-operation-failed`, or when the +// stream is closed, giving `closed`. +// +// When the caller gives a `len` of 0, it represents a request to +// read 0 bytes. If the stream is still open, this call should +// succeed and return an empty list, or otherwise fail with `closed`. +// +// The `len` parameter is a `u64`, which could represent a list of u8 which +// is not possible to allocate in wasm32, or not desirable to allocate as +// as a return value by the callee. The callee may return a list of bytes +// less than `len` in size while more bytes are available for reading. +extern bool streams_method_input_stream_read(streams_borrow_input_stream_t self, uint64_t len, wasip2_list_u8_t *ret, streams_stream_error_t *err); +// Read bytes from a stream, after blocking until at least one byte can +// be read. Except for blocking, behavior is identical to `read`. +extern bool streams_method_input_stream_blocking_read(streams_borrow_input_stream_t self, uint64_t len, wasip2_list_u8_t *ret, streams_stream_error_t *err); +// Skip bytes from a stream. Returns number of bytes skipped. +// +// Behaves identical to `read`, except instead of returning a list +// of bytes, returns the number of bytes consumed from the stream. +extern bool streams_method_input_stream_skip(streams_borrow_input_stream_t self, uint64_t len, uint64_t *ret, streams_stream_error_t *err); +// Skip bytes from a stream, after blocking until at least one byte +// can be skipped. Except for blocking behavior, identical to `skip`. +extern bool streams_method_input_stream_blocking_skip(streams_borrow_input_stream_t self, uint64_t len, uint64_t *ret, streams_stream_error_t *err); +// Create a `pollable` which will resolve once either the specified stream +// has bytes available to read or the other end of the stream has been +// closed. +// The created `pollable` is a child resource of the `input-stream`. +// Implementations may trap if the `input-stream` is dropped before +// all derived `pollable`s created with this function are dropped. +extern streams_own_pollable_t streams_method_input_stream_subscribe(streams_borrow_input_stream_t self); +// Check readiness for writing. This function never blocks. +// +// Returns the number of bytes permitted for the next call to `write`, +// or an error. Calling `write` with more bytes than this function has +// permitted will trap. +// +// When this function returns 0 bytes, the `subscribe` pollable will +// become ready when this function will report at least 1 byte, or an +// error. +extern bool streams_method_output_stream_check_write(streams_borrow_output_stream_t self, uint64_t *ret, streams_stream_error_t *err); +// Perform a write. This function never blocks. +// +// When the destination of a `write` is binary data, the bytes from +// `contents` are written verbatim. When the destination of a `write` is +// known to the implementation to be text, the bytes of `contents` are +// transcoded from UTF-8 into the encoding of the destination and then +// written. +// +// Precondition: check-write gave permit of Ok(n) and contents has a +// length of less than or equal to n. Otherwise, this function will trap. +// +// returns Err(closed) without writing if the stream has closed since +// the last call to check-write provided a permit. +extern bool streams_method_output_stream_write(streams_borrow_output_stream_t self, wasip2_list_u8_t *contents, streams_stream_error_t *err); +// Perform a write of up to 4096 bytes, and then flush the stream. Block +// until all of these operations are complete, or an error occurs. +// +// This is a convenience wrapper around the use of `check-write`, +// `subscribe`, `write`, and `flush`, and is implemented with the +// following pseudo-code: +// +// ```text +// let pollable = this.subscribe(); +// while !contents.is_empty() { +// // Wait for the stream to become writable +// pollable.block(); +// let Ok(n) = this.check-write(); // eliding error handling +// let len = min(n, contents.len()); +// let (chunk, rest) = contents.split_at(len); +// this.write(chunk ); // eliding error handling +// contents = rest; +// } +// this.flush(); +// // Wait for completion of `flush` +// pollable.block(); +// // Check for any errors that arose during `flush` +// let _ = this.check-write(); // eliding error handling +// ``` +extern bool streams_method_output_stream_blocking_write_and_flush(streams_borrow_output_stream_t self, wasip2_list_u8_t *contents, streams_stream_error_t *err); +// Request to flush buffered output. This function never blocks. +// +// This tells the output-stream that the caller intends any buffered +// output to be flushed. the output which is expected to be flushed +// is all that has been passed to `write` prior to this call. +// +// Upon calling this function, the `output-stream` will not accept any +// writes (`check-write` will return `ok(0)`) until the flush has +// completed. The `subscribe` pollable will become ready when the +// flush has completed and the stream can accept more writes. +extern bool streams_method_output_stream_flush(streams_borrow_output_stream_t self, streams_stream_error_t *err); +// Request to flush buffered output, and block until flush completes +// and stream is ready for writing again. +extern bool streams_method_output_stream_blocking_flush(streams_borrow_output_stream_t self, streams_stream_error_t *err); +// Create a `pollable` which will resolve once the output-stream +// is ready for more writing, or an error has occured. When this +// pollable is ready, `check-write` will return `ok(n)` with n>0, or an +// error. +// +// If the stream is closed, this pollable is always ready immediately. +// +// The created `pollable` is a child resource of the `output-stream`. +// Implementations may trap if the `output-stream` is dropped before +// all derived `pollable`s created with this function are dropped. +extern streams_own_pollable_t streams_method_output_stream_subscribe(streams_borrow_output_stream_t self); +// Write zeroes to a stream. +// +// This should be used precisely like `write` with the exact same +// preconditions (must use check-write first), but instead of +// passing a list of bytes, you simply pass the number of zero-bytes +// that should be written. +extern bool streams_method_output_stream_write_zeroes(streams_borrow_output_stream_t self, uint64_t len, streams_stream_error_t *err); +// Perform a write of up to 4096 zeroes, and then flush the stream. +// Block until all of these operations are complete, or an error +// occurs. +// +// This is a convenience wrapper around the use of `check-write`, +// `subscribe`, `write-zeroes`, and `flush`, and is implemented with +// the following pseudo-code: +// +// ```text +// let pollable = this.subscribe(); +// while num_zeroes != 0 { +// // Wait for the stream to become writable +// pollable.block(); +// let Ok(n) = this.check-write(); // eliding error handling +// let len = min(n, num_zeroes); +// this.write-zeroes(len); // eliding error handling +// num_zeroes -= len; +// } +// this.flush(); +// // Wait for completion of `flush` +// pollable.block(); +// // Check for any errors that arose during `flush` +// let _ = this.check-write(); // eliding error handling +// ``` +extern bool streams_method_output_stream_blocking_write_zeroes_and_flush(streams_borrow_output_stream_t self, uint64_t len, streams_stream_error_t *err); +// Read from one stream and write to another. +// +// The behavior of splice is equivelant to: +// 1. calling `check-write` on the `output-stream` +// 2. calling `read` on the `input-stream` with the smaller of the +// `check-write` permitted length and the `len` provided to `splice` +// 3. calling `write` on the `output-stream` with that read data. +// +// Any error reported by the call to `check-write`, `read`, or +// `write` ends the splice and reports that error. +// +// This function returns the number of bytes transferred; it may be less +// than `len`. +extern bool streams_method_output_stream_splice(streams_borrow_output_stream_t self, streams_borrow_input_stream_t src, uint64_t len, uint64_t *ret, streams_stream_error_t *err); +// Read from one stream and write to another, with blocking. +// +// This is similar to `splice`, except that it blocks until the +// `output-stream` is ready for writing, and the `input-stream` +// is ready for reading, before performing the `splice`. +extern bool streams_method_output_stream_blocking_splice(streams_borrow_output_stream_t self, streams_borrow_input_stream_t src, uint64_t len, uint64_t *ret, streams_stream_error_t *err); + +// Imported Functions from `wasi:cli/stdin@0.2.0` +extern stdin_own_input_stream_t stdin_get_stdin(void); + +// Imported Functions from `wasi:cli/stdout@0.2.0` +extern stdout_own_output_stream_t stdout_get_stdout(void); + +// Imported Functions from `wasi:cli/stderr@0.2.0` +extern stderr_own_output_stream_t stderr_get_stderr(void); + +// Imported Functions from `wasi:cli/terminal-stdin@0.2.0` +// If stdin is connected to a terminal, return a `terminal-input` handle +// allowing further interaction with it. +extern bool terminal_stdin_get_terminal_stdin(terminal_stdin_own_terminal_input_t *ret); + +// Imported Functions from `wasi:cli/terminal-stdout@0.2.0` +// If stdout is connected to a terminal, return a `terminal-output` handle +// allowing further interaction with it. +extern bool terminal_stdout_get_terminal_stdout(terminal_stdout_own_terminal_output_t *ret); + +// Imported Functions from `wasi:cli/terminal-stderr@0.2.0` +// If stderr is connected to a terminal, return a `terminal-output` handle +// allowing further interaction with it. +extern bool terminal_stderr_get_terminal_stderr(terminal_stderr_own_terminal_output_t *ret); + +// Imported Functions from `wasi:clocks/monotonic-clock@0.2.0` +// Read the current value of the clock. +// +// The clock is monotonic, therefore calling this function repeatedly will +// produce a sequence of non-decreasing values. +extern monotonic_clock_instant_t monotonic_clock_now(void); +// Query the resolution of the clock. Returns the duration of time +// corresponding to a clock tick. +extern monotonic_clock_duration_t monotonic_clock_resolution(void); +// Create a `pollable` which will resolve once the specified instant +// occured. +extern monotonic_clock_own_pollable_t monotonic_clock_subscribe_instant(monotonic_clock_instant_t when); +// Create a `pollable` which will resolve once the given duration has +// elapsed, starting at the time at which this function was called. +// occured. +extern monotonic_clock_own_pollable_t monotonic_clock_subscribe_duration(monotonic_clock_duration_t when); + +// Imported Functions from `wasi:clocks/wall-clock@0.2.0` +// Read the current value of the clock. +// +// This clock is not monotonic, therefore calling this function repeatedly +// will not necessarily produce a sequence of non-decreasing values. +// +// The returned timestamps represent the number of seconds since +// 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch], +// also known as [Unix Time]. +// +// The nanoseconds field of the output is always less than 1000000000. +// +// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16 +// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time +extern void wall_clock_now(wall_clock_datetime_t *ret); +// Query the resolution of the clock. +// +// The nanoseconds field of the output is always less than 1000000000. +extern void wall_clock_resolution(wall_clock_datetime_t *ret); + +// Imported Functions from `wasi:filesystem/types@0.2.0` +// Return a stream for reading from a file, if available. +// +// May fail with an error-code describing why the file cannot be read. +// +// Multiple read, write, and append streams may be active on the same open +// file and they do not interfere with each other. +// +// Note: This allows using `read-stream`, which is similar to `read` in POSIX. +extern bool filesystem_method_descriptor_read_via_stream(filesystem_borrow_descriptor_t self, filesystem_filesize_t offset, filesystem_own_input_stream_t *ret, filesystem_error_code_t *err); +// Return a stream for writing to a file, if available. +// +// May fail with an error-code describing why the file cannot be written. +// +// Note: This allows using `write-stream`, which is similar to `write` in +// POSIX. +extern bool filesystem_method_descriptor_write_via_stream(filesystem_borrow_descriptor_t self, filesystem_filesize_t offset, filesystem_own_output_stream_t *ret, filesystem_error_code_t *err); +// Return a stream for appending to a file, if available. +// +// May fail with an error-code describing why the file cannot be appended. +// +// Note: This allows using `write-stream`, which is similar to `write` with +// `O_APPEND` in in POSIX. +extern bool filesystem_method_descriptor_append_via_stream(filesystem_borrow_descriptor_t self, filesystem_own_output_stream_t *ret, filesystem_error_code_t *err); +// Provide file advisory information on a descriptor. +// +// This is similar to `posix_fadvise` in POSIX. +extern bool filesystem_method_descriptor_advise(filesystem_borrow_descriptor_t self, filesystem_filesize_t offset, filesystem_filesize_t length, filesystem_advice_t advice, filesystem_error_code_t *err); +// Synchronize the data of a file to disk. +// +// This function succeeds with no effect if the file descriptor is not +// opened for writing. +// +// Note: This is similar to `fdatasync` in POSIX. +extern bool filesystem_method_descriptor_sync_data(filesystem_borrow_descriptor_t self, filesystem_error_code_t *err); +// Get flags associated with a descriptor. +// +// Note: This returns similar flags to `fcntl(fd, F_GETFL)` in POSIX. +// +// Note: This returns the value that was the `fs_flags` value returned +// from `fdstat_get` in earlier versions of WASI. +extern bool filesystem_method_descriptor_get_flags(filesystem_borrow_descriptor_t self, filesystem_descriptor_flags_t *ret, filesystem_error_code_t *err); +// Get the dynamic type of a descriptor. +// +// Note: This returns the same value as the `type` field of the `fd-stat` +// returned by `stat`, `stat-at` and similar. +// +// Note: This returns similar flags to the `st_mode & S_IFMT` value provided +// by `fstat` in POSIX. +// +// Note: This returns the value that was the `fs_filetype` value returned +// from `fdstat_get` in earlier versions of WASI. +extern bool filesystem_method_descriptor_get_type(filesystem_borrow_descriptor_t self, filesystem_descriptor_type_t *ret, filesystem_error_code_t *err); +// Adjust the size of an open file. If this increases the file's size, the +// extra bytes are filled with zeros. +// +// Note: This was called `fd_filestat_set_size` in earlier versions of WASI. +extern bool filesystem_method_descriptor_set_size(filesystem_borrow_descriptor_t self, filesystem_filesize_t size, filesystem_error_code_t *err); +// Adjust the timestamps of an open file or directory. +// +// Note: This is similar to `futimens` in POSIX. +// +// Note: This was called `fd_filestat_set_times` in earlier versions of WASI. +extern bool filesystem_method_descriptor_set_times(filesystem_borrow_descriptor_t self, filesystem_new_timestamp_t *data_access_timestamp, filesystem_new_timestamp_t *data_modification_timestamp, filesystem_error_code_t *err); +// Read from a descriptor, without using and updating the descriptor's offset. +// +// This function returns a list of bytes containing the data that was +// read, along with a bool which, when true, indicates that the end of the +// file was reached. The returned list will contain up to `length` bytes; it +// may return fewer than requested, if the end of the file is reached or +// if the I/O operation is interrupted. +// +// In the future, this may change to return a `stream<u8, error-code>`. +// +// Note: This is similar to `pread` in POSIX. +extern bool filesystem_method_descriptor_read(filesystem_borrow_descriptor_t self, filesystem_filesize_t length, filesystem_filesize_t offset, wasip2_tuple2_list_u8_bool_t *ret, filesystem_error_code_t *err); +// Write to a descriptor, without using and updating the descriptor's offset. +// +// It is valid to write past the end of a file; the file is extended to the +// extent of the write, with bytes between the previous end and the start of +// the write set to zero. +// +// In the future, this may change to take a `stream<u8, error-code>`. +// +// Note: This is similar to `pwrite` in POSIX. +extern bool filesystem_method_descriptor_write(filesystem_borrow_descriptor_t self, wasip2_list_u8_t *buffer, filesystem_filesize_t offset, filesystem_filesize_t *ret, filesystem_error_code_t *err); +// Read directory entries from a directory. +// +// On filesystems where directories contain entries referring to themselves +// and their parents, often named `.` and `..` respectively, these entries +// are omitted. +// +// This always returns a new stream which starts at the beginning of the +// directory. Multiple streams may be active on the same directory, and they +// do not interfere with each other. +extern bool filesystem_method_descriptor_read_directory(filesystem_borrow_descriptor_t self, filesystem_own_directory_entry_stream_t *ret, filesystem_error_code_t *err); +// Synchronize the data and metadata of a file to disk. +// +// This function succeeds with no effect if the file descriptor is not +// opened for writing. +// +// Note: This is similar to `fsync` in POSIX. +extern bool filesystem_method_descriptor_sync(filesystem_borrow_descriptor_t self, filesystem_error_code_t *err); +// Create a directory. +// +// Note: This is similar to `mkdirat` in POSIX. +extern bool filesystem_method_descriptor_create_directory_at(filesystem_borrow_descriptor_t self, wasip2_string_t *path, filesystem_error_code_t *err); +// Return the attributes of an open file or directory. +// +// Note: This is similar to `fstat` in POSIX, except that it does not return +// device and inode information. For testing whether two descriptors refer to +// the same underlying filesystem object, use `is-same-object`. To obtain +// additional data that can be used do determine whether a file has been +// modified, use `metadata-hash`. +// +// Note: This was called `fd_filestat_get` in earlier versions of WASI. +extern bool filesystem_method_descriptor_stat(filesystem_borrow_descriptor_t self, filesystem_descriptor_stat_t *ret, filesystem_error_code_t *err); +// Return the attributes of a file or directory. +// +// Note: This is similar to `fstatat` in POSIX, except that it does not +// return device and inode information. See the `stat` description for a +// discussion of alternatives. +// +// Note: This was called `path_filestat_get` in earlier versions of WASI. +extern bool filesystem_method_descriptor_stat_at(filesystem_borrow_descriptor_t self, filesystem_path_flags_t path_flags, wasip2_string_t *path, filesystem_descriptor_stat_t *ret, filesystem_error_code_t *err); +// Adjust the timestamps of a file or directory. +// +// Note: This is similar to `utimensat` in POSIX. +// +// Note: This was called `path_filestat_set_times` in earlier versions of +// WASI. +extern bool filesystem_method_descriptor_set_times_at(filesystem_borrow_descriptor_t self, filesystem_path_flags_t path_flags, wasip2_string_t *path, filesystem_new_timestamp_t *data_access_timestamp, filesystem_new_timestamp_t *data_modification_timestamp, filesystem_error_code_t *err); +// Create a hard link. +// +// Note: This is similar to `linkat` in POSIX. +extern bool filesystem_method_descriptor_link_at(filesystem_borrow_descriptor_t self, filesystem_path_flags_t old_path_flags, wasip2_string_t *old_path, filesystem_borrow_descriptor_t new_descriptor, wasip2_string_t *new_path, filesystem_error_code_t *err); +// Open a file or directory. +// +// The returned descriptor is not guaranteed to be the lowest-numbered +// descriptor not currently open/ it is randomized to prevent applications +// from depending on making assumptions about indexes, since this is +// error-prone in multi-threaded contexts. The returned descriptor is +// guaranteed to be less than 2**31. +// +// If `flags` contains `descriptor-flags::mutate-directory`, and the base +// descriptor doesn't have `descriptor-flags::mutate-directory` set, +// `open-at` fails with `error-code::read-only`. +// +// If `flags` contains `write` or `mutate-directory`, or `open-flags` +// contains `truncate` or `create`, and the base descriptor doesn't have +// `descriptor-flags::mutate-directory` set, `open-at` fails with +// `error-code::read-only`. +// +// Note: This is similar to `openat` in POSIX. +extern bool filesystem_method_descriptor_open_at(filesystem_borrow_descriptor_t self, filesystem_path_flags_t path_flags, wasip2_string_t *path, filesystem_open_flags_t open_flags, filesystem_descriptor_flags_t flags, filesystem_own_descriptor_t *ret, filesystem_error_code_t *err); +// Read the contents of a symbolic link. +// +// If the contents contain an absolute or rooted path in the underlying +// filesystem, this function fails with `error-code::not-permitted`. +// +// Note: This is similar to `readlinkat` in POSIX. +extern bool filesystem_method_descriptor_readlink_at(filesystem_borrow_descriptor_t self, wasip2_string_t *path, wasip2_string_t *ret, filesystem_error_code_t *err); +// Remove a directory. +// +// Return `error-code::not-empty` if the directory is not empty. +// +// Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX. +extern bool filesystem_method_descriptor_remove_directory_at(filesystem_borrow_descriptor_t self, wasip2_string_t *path, filesystem_error_code_t *err); +// Rename a filesystem object. +// +// Note: This is similar to `renameat` in POSIX. +extern bool filesystem_method_descriptor_rename_at(filesystem_borrow_descriptor_t self, wasip2_string_t *old_path, filesystem_borrow_descriptor_t new_descriptor, wasip2_string_t *new_path, filesystem_error_code_t *err); +// Create a symbolic link (also known as a "symlink"). +// +// If `old-path` starts with `/`, the function fails with +// `error-code::not-permitted`. +// +// Note: This is similar to `symlinkat` in POSIX. +extern bool filesystem_method_descriptor_symlink_at(filesystem_borrow_descriptor_t self, wasip2_string_t *old_path, wasip2_string_t *new_path, filesystem_error_code_t *err); +// Unlink a filesystem object that is not a directory. +// +// Return `error-code::is-directory` if the path refers to a directory. +// Note: This is similar to `unlinkat(fd, path, 0)` in POSIX. +extern bool filesystem_method_descriptor_unlink_file_at(filesystem_borrow_descriptor_t self, wasip2_string_t *path, filesystem_error_code_t *err); +// Test whether two descriptors refer to the same filesystem object. +// +// In POSIX, this corresponds to testing whether the two descriptors have the +// same device (`st_dev`) and inode (`st_ino` or `d_ino`) numbers. +// wasi-filesystem does not expose device and inode numbers, so this function +// may be used instead. +extern bool filesystem_method_descriptor_is_same_object(filesystem_borrow_descriptor_t self, filesystem_borrow_descriptor_t other); +// Return a hash of the metadata associated with a filesystem object referred +// to by a descriptor. +// +// This returns a hash of the last-modification timestamp and file size, and +// may also include the inode number, device number, birth timestamp, and +// other metadata fields that may change when the file is modified or +// replaced. It may also include a secret value chosen by the +// implementation and not otherwise exposed. +// +// Implementations are encourated to provide the following properties: +// +// - If the file is not modified or replaced, the computed hash value should +// usually not change. +// - If the object is modified or replaced, the computed hash value should +// usually change. +// - The inputs to the hash should not be easily computable from the +// computed hash. +// +// However, none of these is required. +extern bool filesystem_method_descriptor_metadata_hash(filesystem_borrow_descriptor_t self, filesystem_metadata_hash_value_t *ret, filesystem_error_code_t *err); +// Return a hash of the metadata associated with a filesystem object referred +// to by a directory descriptor and a relative path. +// +// This performs the same hash computation as `metadata-hash`. +extern bool filesystem_method_descriptor_metadata_hash_at(filesystem_borrow_descriptor_t self, filesystem_path_flags_t path_flags, wasip2_string_t *path, filesystem_metadata_hash_value_t *ret, filesystem_error_code_t *err); +// Read a single directory entry from a `directory-entry-stream`. +extern bool filesystem_method_directory_entry_stream_read_directory_entry(filesystem_borrow_directory_entry_stream_t self, filesystem_option_directory_entry_t *ret, filesystem_error_code_t *err); +// Attempts to extract a filesystem-related `error-code` from the stream +// `error` provided. +// +// Stream operations which return `stream-error::last-operation-failed` +// have a payload with more information about the operation that failed. +// This payload can be passed through to this function to see if there's +// filesystem-related information about the error to return. +// +// Note that this function is fallible because not all stream-related +// errors are filesystem-related errors. +extern bool filesystem_filesystem_error_code(filesystem_borrow_error_t err_, filesystem_error_code_t *ret); + +// Imported Functions from `wasi:filesystem/preopens@0.2.0` +// Return the set of preopened directories, and their path. +extern void filesystem_preopens_get_directories(filesystem_preopens_list_tuple2_own_descriptor_string_t *ret); + +// Imported Functions from `wasi:sockets/instance-network@0.2.0` +// Get a handle to the default network. +extern instance_network_own_network_t instance_network_instance_network(void); + +// Imported Functions from `wasi:sockets/udp@0.2.0` +// Bind the socket to a specific network on the provided IP address and port. +// +// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the implementation to decide which +// network interface(s) to bind to. +// If the port is zero, the socket will be bound to a random free port. +// +// # Typical errors +// - `invalid-argument`: The `local-address` has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows) +// - `invalid-state`: The socket is already bound. (EINVAL) +// - `address-in-use`: No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows) +// - `address-in-use`: Address is already in use. (EADDRINUSE) +// - `address-not-bindable`: `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL) +// - `not-in-progress`: A `bind` operation is not in progress. +// - `would-block`: Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN) +// +// # Implementors note +// Unlike in POSIX, in WASI the bind operation is async. This enables +// interactive WASI hosts to inject permission prompts. Runtimes that +// don't want to make use of this ability can simply call the native +// `bind` as part of either `start-bind` or `finish-bind`. +// +// # References +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html> +// - <https://man7.org/linux/man-pages/man2/bind.2.html> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind> +// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html> +extern bool udp_method_udp_socket_start_bind(udp_borrow_udp_socket_t self, udp_borrow_network_t network, udp_ip_socket_address_t *local_address, udp_error_code_t *err); +extern bool udp_method_udp_socket_finish_bind(udp_borrow_udp_socket_t self, udp_error_code_t *err); +// Set up inbound & outbound communication channels, optionally to a specific peer. +// +// This function only changes the local socket configuration and does not generate any network traffic. +// On success, the `remote-address` of the socket is updated. The `local-address` may be updated as well, +// based on the best network path to `remote-address`. +// +// When a `remote-address` is provided, the returned streams are limited to communicating with that specific peer: +// - `send` can only be used to send to this destination. +// - `receive` will only return datagrams sent from the provided `remote-address`. +// +// This method may be called multiple times on the same socket to change its association, but +// only the most recently returned pair of streams will be operational. Implementations may trap if +// the streams returned by a previous invocation haven't been dropped yet before calling `stream` again. +// +// The POSIX equivalent in pseudo-code is: +// ```text +// if (was previously connected) { +// connect(s, AF_UNSPEC) +// } +// if (remote_address is Some) { +// connect(s, remote_address) +// } +// ``` +// +// Unlike in POSIX, the socket must already be explicitly bound. +// +// # Typical errors +// - `invalid-argument`: The `remote-address` has the wrong address family. (EAFNOSUPPORT) +// - `invalid-argument`: The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL) +// - `invalid-argument`: The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL) +// - `invalid-state`: The socket is not bound. +// - `address-in-use`: Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD) +// - `remote-unreachable`: The remote address is not reachable. (ECONNRESET, ENETRESET, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET) +// - `connection-refused`: The connection was refused. (ECONNREFUSED) +// +// # References +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html> +// - <https://man7.org/linux/man-pages/man2/connect.2.html> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect> +// - <https://man.freebsd.org/cgi/man.cgi?connect> +extern bool udp_method_udp_socket_stream(udp_borrow_udp_socket_t self, udp_ip_socket_address_t *maybe_remote_address, udp_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_t *ret, udp_error_code_t *err); +// Get the current bound address. +// +// POSIX mentions: +// > If the socket has not been bound to a local name, the value +// > stored in the object pointed to by `address` is unspecified. +// +// WASI is stricter and requires `local-address` to return `invalid-state` when the socket hasn't been bound yet. +// +// # Typical errors +// - `invalid-state`: The socket is not bound to any local address. +// +// # References +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html> +// - <https://man7.org/linux/man-pages/man2/getsockname.2.html> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname> +// - <https://man.freebsd.org/cgi/man.cgi?getsockname> +extern bool udp_method_udp_socket_local_address(udp_borrow_udp_socket_t self, udp_ip_socket_address_t *ret, udp_error_code_t *err); +// Get the address the socket is currently streaming to. +// +// # Typical errors +// - `invalid-state`: The socket is not streaming to a specific remote address. (ENOTCONN) +// +// # References +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html> +// - <https://man7.org/linux/man-pages/man2/getpeername.2.html> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername> +// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1> +extern bool udp_method_udp_socket_remote_address(udp_borrow_udp_socket_t self, udp_ip_socket_address_t *ret, udp_error_code_t *err); +// Whether this is a IPv4 or IPv6 socket. +// +// Equivalent to the SO_DOMAIN socket option. +extern udp_ip_address_family_t udp_method_udp_socket_address_family(udp_borrow_udp_socket_t self); +// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options. +// +// If the provided value is 0, an `invalid-argument` error is returned. +// +// # Typical errors +// - `invalid-argument`: (set) The TTL value must be 1 or higher. +extern bool udp_method_udp_socket_unicast_hop_limit(udp_borrow_udp_socket_t self, uint8_t *ret, udp_error_code_t *err); +extern bool udp_method_udp_socket_set_unicast_hop_limit(udp_borrow_udp_socket_t self, uint8_t value, udp_error_code_t *err); +// The kernel buffer space reserved for sends/receives on this socket. +// +// If the provided value is 0, an `invalid-argument` error is returned. +// Any other value will never cause an error, but it might be silently clamped and/or rounded. +// I.e. after setting a value, reading the same setting back may return a different value. +// +// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options. +// +// # Typical errors +// - `invalid-argument`: (set) The provided value was 0. +extern bool udp_method_udp_socket_receive_buffer_size(udp_borrow_udp_socket_t self, uint64_t *ret, udp_error_code_t *err); +extern bool udp_method_udp_socket_set_receive_buffer_size(udp_borrow_udp_socket_t self, uint64_t value, udp_error_code_t *err); +extern bool udp_method_udp_socket_send_buffer_size(udp_borrow_udp_socket_t self, uint64_t *ret, udp_error_code_t *err); +extern bool udp_method_udp_socket_set_send_buffer_size(udp_borrow_udp_socket_t self, uint64_t value, udp_error_code_t *err); +// Create a `pollable` which will resolve once the socket is ready for I/O. +// +// Note: this function is here for WASI Preview2 only. +// It's planned to be removed when `future` is natively supported in Preview3. +extern udp_own_pollable_t udp_method_udp_socket_subscribe(udp_borrow_udp_socket_t self); +// Receive messages on the socket. +// +// This function attempts to receive up to `max-results` datagrams on the socket without blocking. +// The returned list may contain fewer elements than requested, but never more. +// +// This function returns successfully with an empty list when either: +// - `max-results` is 0, or: +// - `max-results` is greater than 0, but no results are immediately available. +// This function never returns `error(would-block)`. +// +// # Typical errors +// - `remote-unreachable`: The remote address is not reachable. (ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET) +// - `connection-refused`: The connection was refused. (ECONNREFUSED) +// +// # References +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvfrom.html> +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvmsg.html> +// - <https://man7.org/linux/man-pages/man2/recv.2.html> +// - <https://man7.org/linux/man-pages/man2/recvmmsg.2.html> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recv> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recvfrom> +// - <https://learn.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms741687(v=vs.85)> +// - <https://man.freebsd.org/cgi/man.cgi?query=recv&sektion=2> +extern bool udp_method_incoming_datagram_stream_receive(udp_borrow_incoming_datagram_stream_t self, uint64_t max_results, udp_list_incoming_datagram_t *ret, udp_error_code_t *err); +// Create a `pollable` which will resolve once the stream is ready to receive again. +// +// Note: this function is here for WASI Preview2 only. +// It's planned to be removed when `future` is natively supported in Preview3. +extern udp_own_pollable_t udp_method_incoming_datagram_stream_subscribe(udp_borrow_incoming_datagram_stream_t self); +// Check readiness for sending. This function never blocks. +// +// Returns the number of datagrams permitted for the next call to `send`, +// or an error. Calling `send` with more datagrams than this function has +// permitted will trap. +// +// When this function returns ok(0), the `subscribe` pollable will +// become ready when this function will report at least ok(1), or an +// error. +// +// Never returns `would-block`. +extern bool udp_method_outgoing_datagram_stream_check_send(udp_borrow_outgoing_datagram_stream_t self, uint64_t *ret, udp_error_code_t *err); +// Send messages on the socket. +// +// This function attempts to send all provided `datagrams` on the socket without blocking and +// returns how many messages were actually sent (or queued for sending). This function never +// returns `error(would-block)`. If none of the datagrams were able to be sent, `ok(0)` is returned. +// +// This function semantically behaves the same as iterating the `datagrams` list and sequentially +// sending each individual datagram until either the end of the list has been reached or the first error occurred. +// If at least one datagram has been sent successfully, this function never returns an error. +// +// If the input list is empty, the function returns `ok(0)`. +// +// Each call to `send` must be permitted by a preceding `check-send`. Implementations must trap if +// either `check-send` was not called or `datagrams` contains more items than `check-send` permitted. +// +// # Typical errors +// - `invalid-argument`: The `remote-address` has the wrong address family. (EAFNOSUPPORT) +// - `invalid-argument`: The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL) +// - `invalid-argument`: The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL) +// - `invalid-argument`: The socket is in "connected" mode and `remote-address` is `some` value that does not match the address passed to `stream`. (EISCONN) +// - `invalid-argument`: The socket is not "connected" and no value for `remote-address` was provided. (EDESTADDRREQ) +// - `remote-unreachable`: The remote address is not reachable. (ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET) +// - `connection-refused`: The connection was refused. (ECONNREFUSED) +// - `datagram-too-large`: The datagram is too large. (EMSGSIZE) +// +// # References +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendto.html> +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendmsg.html> +// - <https://man7.org/linux/man-pages/man2/send.2.html> +// - <https://man7.org/linux/man-pages/man2/sendmmsg.2.html> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-send> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-sendto> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasendmsg> +// - <https://man.freebsd.org/cgi/man.cgi?query=send&sektion=2> +extern bool udp_method_outgoing_datagram_stream_send(udp_borrow_outgoing_datagram_stream_t self, udp_list_outgoing_datagram_t *datagrams, uint64_t *ret, udp_error_code_t *err); +// Create a `pollable` which will resolve once the stream is ready to send again. +// +// Note: this function is here for WASI Preview2 only. +// It's planned to be removed when `future` is natively supported in Preview3. +extern udp_own_pollable_t udp_method_outgoing_datagram_stream_subscribe(udp_borrow_outgoing_datagram_stream_t self); + +// Imported Functions from `wasi:sockets/udp-create-socket@0.2.0` +// Create a new UDP socket. +// +// Similar to `socket(AF_INET or AF_INET6, SOCK_DGRAM, IPPROTO_UDP)` in POSIX. +// On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise. +// +// This function does not require a network capability handle. This is considered to be safe because +// at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind` is called, +// the socket is effectively an in-memory configuration object, unable to communicate with the outside world. +// +// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations. +// +// # Typical errors +// - `not-supported`: The specified `address-family` is not supported. (EAFNOSUPPORT) +// - `new-socket-limit`: The new socket resource could not be created because of a system limit. (EMFILE, ENFILE) +// +// # References: +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html> +// - <https://man7.org/linux/man-pages/man2/socket.2.html> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw> +// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2> +extern bool udp_create_socket_create_udp_socket(udp_create_socket_ip_address_family_t address_family, udp_create_socket_own_udp_socket_t *ret, udp_create_socket_error_code_t *err); + +// Imported Functions from `wasi:sockets/tcp@0.2.0` +// Bind the socket to a specific network on the provided IP address and port. +// +// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the implementation to decide which +// network interface(s) to bind to. +// If the TCP/UDP port is zero, the socket will be bound to a random free port. +// +// Bind can be attempted multiple times on the same socket, even with +// different arguments on each iteration. But never concurrently and +// only as long as the previous bind failed. Once a bind succeeds, the +// binding can't be changed anymore. +// +// # Typical errors +// - `invalid-argument`: The `local-address` has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows) +// - `invalid-argument`: `local-address` is not a unicast address. (EINVAL) +// - `invalid-argument`: `local-address` is an IPv4-mapped IPv6 address. (EINVAL) +// - `invalid-state`: The socket is already bound. (EINVAL) +// - `address-in-use`: No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows) +// - `address-in-use`: Address is already in use. (EADDRINUSE) +// - `address-not-bindable`: `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL) +// - `not-in-progress`: A `bind` operation is not in progress. +// - `would-block`: Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN) +// +// # Implementors note +// When binding to a non-zero port, this bind operation shouldn't be affected by the TIME_WAIT +// state of a recently closed socket on the same local address. In practice this means that the SO_REUSEADDR +// socket option should be set implicitly on all platforms, except on Windows where this is the default behavior +// and SO_REUSEADDR performs something different entirely. +// +// Unlike in POSIX, in WASI the bind operation is async. This enables +// interactive WASI hosts to inject permission prompts. Runtimes that +// don't want to make use of this ability can simply call the native +// `bind` as part of either `start-bind` or `finish-bind`. +// +// # References +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html> +// - <https://man7.org/linux/man-pages/man2/bind.2.html> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind> +// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html> +extern bool tcp_method_tcp_socket_start_bind(tcp_borrow_tcp_socket_t self, tcp_borrow_network_t network, tcp_ip_socket_address_t *local_address, tcp_error_code_t *err); +extern bool tcp_method_tcp_socket_finish_bind(tcp_borrow_tcp_socket_t self, tcp_error_code_t *err); +// Connect to a remote endpoint. +// +// On success: +// - the socket is transitioned into the `connection` state. +// - a pair of streams is returned that can be used to read & write to the connection +// +// After a failed connection attempt, the socket will be in the `closed` +// state and the only valid action left is to `drop` the socket. A single +// socket can not be used to connect more than once. +// +// # Typical errors +// - `invalid-argument`: The `remote-address` has the wrong address family. (EAFNOSUPPORT) +// - `invalid-argument`: `remote-address` is not a unicast address. (EINVAL, ENETUNREACH on Linux, EAFNOSUPPORT on MacOS) +// - `invalid-argument`: `remote-address` is an IPv4-mapped IPv6 address. (EINVAL, EADDRNOTAVAIL on Illumos) +// - `invalid-argument`: The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EADDRNOTAVAIL on Windows) +// - `invalid-argument`: The port in `remote-address` is set to 0. (EADDRNOTAVAIL on Windows) +// - `invalid-argument`: The socket is already attached to a different network. The `network` passed to `connect` must be identical to the one passed to `bind`. +// - `invalid-state`: The socket is already in the `connected` state. (EISCONN) +// - `invalid-state`: The socket is already in the `listening` state. (EOPNOTSUPP, EINVAL on Windows) +// - `timeout`: Connection timed out. (ETIMEDOUT) +// - `connection-refused`: The connection was forcefully rejected. (ECONNREFUSED) +// - `connection-reset`: The connection was reset. (ECONNRESET) +// - `connection-aborted`: The connection was aborted. (ECONNABORTED) +// - `remote-unreachable`: The remote address is not reachable. (EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET) +// - `address-in-use`: Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD) +// - `not-in-progress`: A connect operation is not in progress. +// - `would-block`: Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN) +// +// # Implementors note +// The POSIX equivalent of `start-connect` is the regular `connect` syscall. +// Because all WASI sockets are non-blocking this is expected to return +// EINPROGRESS, which should be translated to `ok()` in WASI. +// +// The POSIX equivalent of `finish-connect` is a `poll` for event `POLLOUT` +// with a timeout of 0 on the socket descriptor. Followed by a check for +// the `SO_ERROR` socket option, in case the poll signaled readiness. +// +// # References +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html> +// - <https://man7.org/linux/man-pages/man2/connect.2.html> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect> +// - <https://man.freebsd.org/cgi/man.cgi?connect> +extern bool tcp_method_tcp_socket_start_connect(tcp_borrow_tcp_socket_t self, tcp_borrow_network_t network, tcp_ip_socket_address_t *remote_address, tcp_error_code_t *err); +extern bool tcp_method_tcp_socket_finish_connect(tcp_borrow_tcp_socket_t self, tcp_tuple2_own_input_stream_own_output_stream_t *ret, tcp_error_code_t *err); +// Start listening for new connections. +// +// Transitions the socket into the `listening` state. +// +// Unlike POSIX, the socket must already be explicitly bound. +// +// # Typical errors +// - `invalid-state`: The socket is not bound to any local address. (EDESTADDRREQ) +// - `invalid-state`: The socket is already in the `connected` state. (EISCONN, EINVAL on BSD) +// - `invalid-state`: The socket is already in the `listening` state. +// - `address-in-use`: Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE) +// - `not-in-progress`: A listen operation is not in progress. +// - `would-block`: Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN) +// +// # Implementors note +// Unlike in POSIX, in WASI the listen operation is async. This enables +// interactive WASI hosts to inject permission prompts. Runtimes that +// don't want to make use of this ability can simply call the native +// `listen` as part of either `start-listen` or `finish-listen`. +// +// # References +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/listen.html> +// - <https://man7.org/linux/man-pages/man2/listen.2.html> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-listen> +// - <https://man.freebsd.org/cgi/man.cgi?query=listen&sektion=2> +extern bool tcp_method_tcp_socket_start_listen(tcp_borrow_tcp_socket_t self, tcp_error_code_t *err); +extern bool tcp_method_tcp_socket_finish_listen(tcp_borrow_tcp_socket_t self, tcp_error_code_t *err); +// Accept a new client socket. +// +// The returned socket is bound and in the `connected` state. The following properties are inherited from the listener socket: +// - `address-family` +// - `keep-alive-enabled` +// - `keep-alive-idle-time` +// - `keep-alive-interval` +// - `keep-alive-count` +// - `hop-limit` +// - `receive-buffer-size` +// - `send-buffer-size` +// +// On success, this function returns the newly accepted client socket along with +// a pair of streams that can be used to read & write to the connection. +// +// # Typical errors +// - `invalid-state`: Socket is not in the `listening` state. (EINVAL) +// - `would-block`: No pending connections at the moment. (EWOULDBLOCK, EAGAIN) +// - `connection-aborted`: An incoming connection was pending, but was terminated by the client before this listener could accept it. (ECONNABORTED) +// - `new-socket-limit`: The new socket resource could not be created because of a system limit. (EMFILE, ENFILE) +// +// # References +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/accept.html> +// - <https://man7.org/linux/man-pages/man2/accept.2.html> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-accept> +// - <https://man.freebsd.org/cgi/man.cgi?query=accept&sektion=2> +extern bool tcp_method_tcp_socket_accept(tcp_borrow_tcp_socket_t self, tcp_tuple3_own_tcp_socket_own_input_stream_own_output_stream_t *ret, tcp_error_code_t *err); +// Get the bound local address. +// +// POSIX mentions: +// > If the socket has not been bound to a local name, the value +// > stored in the object pointed to by `address` is unspecified. +// +// WASI is stricter and requires `local-address` to return `invalid-state` when the socket hasn't been bound yet. +// +// # Typical errors +// - `invalid-state`: The socket is not bound to any local address. +// +// # References +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html> +// - <https://man7.org/linux/man-pages/man2/getsockname.2.html> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname> +// - <https://man.freebsd.org/cgi/man.cgi?getsockname> +extern bool tcp_method_tcp_socket_local_address(tcp_borrow_tcp_socket_t self, tcp_ip_socket_address_t *ret, tcp_error_code_t *err); +// Get the remote address. +// +// # Typical errors +// - `invalid-state`: The socket is not connected to a remote address. (ENOTCONN) +// +// # References +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html> +// - <https://man7.org/linux/man-pages/man2/getpeername.2.html> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername> +// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1> +extern bool tcp_method_tcp_socket_remote_address(tcp_borrow_tcp_socket_t self, tcp_ip_socket_address_t *ret, tcp_error_code_t *err); +// Whether the socket is in the `listening` state. +// +// Equivalent to the SO_ACCEPTCONN socket option. +extern bool tcp_method_tcp_socket_is_listening(tcp_borrow_tcp_socket_t self); +// Whether this is a IPv4 or IPv6 socket. +// +// Equivalent to the SO_DOMAIN socket option. +extern tcp_ip_address_family_t tcp_method_tcp_socket_address_family(tcp_borrow_tcp_socket_t self); +// Hints the desired listen queue size. Implementations are free to ignore this. +// +// If the provided value is 0, an `invalid-argument` error is returned. +// Any other value will never cause an error, but it might be silently clamped and/or rounded. +// +// # Typical errors +// - `not-supported`: (set) The platform does not support changing the backlog size after the initial listen. +// - `invalid-argument`: (set) The provided value was 0. +// - `invalid-state`: (set) The socket is in the `connect-in-progress` or `connected` state. +extern bool tcp_method_tcp_socket_set_listen_backlog_size(tcp_borrow_tcp_socket_t self, uint64_t value, tcp_error_code_t *err); +// Enables or disables keepalive. +// +// The keepalive behavior can be adjusted using: +// - `keep-alive-idle-time` +// - `keep-alive-interval` +// - `keep-alive-count` +// These properties can be configured while `keep-alive-enabled` is false, but only come into effect when `keep-alive-enabled` is true. +// +// Equivalent to the SO_KEEPALIVE socket option. +extern bool tcp_method_tcp_socket_keep_alive_enabled(tcp_borrow_tcp_socket_t self, bool *ret, tcp_error_code_t *err); +extern bool tcp_method_tcp_socket_set_keep_alive_enabled(tcp_borrow_tcp_socket_t self, bool value, tcp_error_code_t *err); +// Amount of time the connection has to be idle before TCP starts sending keepalive packets. +// +// If the provided value is 0, an `invalid-argument` error is returned. +// Any other value will never cause an error, but it might be silently clamped and/or rounded. +// I.e. after setting a value, reading the same setting back may return a different value. +// +// Equivalent to the TCP_KEEPIDLE socket option. (TCP_KEEPALIVE on MacOS) +// +// # Typical errors +// - `invalid-argument`: (set) The provided value was 0. +extern bool tcp_method_tcp_socket_keep_alive_idle_time(tcp_borrow_tcp_socket_t self, tcp_duration_t *ret, tcp_error_code_t *err); +extern bool tcp_method_tcp_socket_set_keep_alive_idle_time(tcp_borrow_tcp_socket_t self, tcp_duration_t value, tcp_error_code_t *err); +// The time between keepalive packets. +// +// If the provided value is 0, an `invalid-argument` error is returned. +// Any other value will never cause an error, but it might be silently clamped and/or rounded. +// I.e. after setting a value, reading the same setting back may return a different value. +// +// Equivalent to the TCP_KEEPINTVL socket option. +// +// # Typical errors +// - `invalid-argument`: (set) The provided value was 0. +extern bool tcp_method_tcp_socket_keep_alive_interval(tcp_borrow_tcp_socket_t self, tcp_duration_t *ret, tcp_error_code_t *err); +extern bool tcp_method_tcp_socket_set_keep_alive_interval(tcp_borrow_tcp_socket_t self, tcp_duration_t value, tcp_error_code_t *err); +// The maximum amount of keepalive packets TCP should send before aborting the connection. +// +// If the provided value is 0, an `invalid-argument` error is returned. +// Any other value will never cause an error, but it might be silently clamped and/or rounded. +// I.e. after setting a value, reading the same setting back may return a different value. +// +// Equivalent to the TCP_KEEPCNT socket option. +// +// # Typical errors +// - `invalid-argument`: (set) The provided value was 0. +extern bool tcp_method_tcp_socket_keep_alive_count(tcp_borrow_tcp_socket_t self, uint32_t *ret, tcp_error_code_t *err); +extern bool tcp_method_tcp_socket_set_keep_alive_count(tcp_borrow_tcp_socket_t self, uint32_t value, tcp_error_code_t *err); +// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options. +// +// If the provided value is 0, an `invalid-argument` error is returned. +// +// # Typical errors +// - `invalid-argument`: (set) The TTL value must be 1 or higher. +extern bool tcp_method_tcp_socket_hop_limit(tcp_borrow_tcp_socket_t self, uint8_t *ret, tcp_error_code_t *err); +extern bool tcp_method_tcp_socket_set_hop_limit(tcp_borrow_tcp_socket_t self, uint8_t value, tcp_error_code_t *err); +// The kernel buffer space reserved for sends/receives on this socket. +// +// If the provided value is 0, an `invalid-argument` error is returned. +// Any other value will never cause an error, but it might be silently clamped and/or rounded. +// I.e. after setting a value, reading the same setting back may return a different value. +// +// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options. +// +// # Typical errors +// - `invalid-argument`: (set) The provided value was 0. +extern bool tcp_method_tcp_socket_receive_buffer_size(tcp_borrow_tcp_socket_t self, uint64_t *ret, tcp_error_code_t *err); +extern bool tcp_method_tcp_socket_set_receive_buffer_size(tcp_borrow_tcp_socket_t self, uint64_t value, tcp_error_code_t *err); +extern bool tcp_method_tcp_socket_send_buffer_size(tcp_borrow_tcp_socket_t self, uint64_t *ret, tcp_error_code_t *err); +extern bool tcp_method_tcp_socket_set_send_buffer_size(tcp_borrow_tcp_socket_t self, uint64_t value, tcp_error_code_t *err); +// Create a `pollable` which can be used to poll for, or block on, +// completion of any of the asynchronous operations of this socket. +// +// When `finish-bind`, `finish-listen`, `finish-connect` or `accept` +// return `error(would-block)`, this pollable can be used to wait for +// their success or failure, after which the method can be retried. +// +// The pollable is not limited to the async operation that happens to be +// in progress at the time of calling `subscribe` (if any). Theoretically, +// `subscribe` only has to be called once per socket and can then be +// (re)used for the remainder of the socket's lifetime. +// +// See <https://github.com/WebAssembly/wasi-sockets/TcpSocketOperationalSemantics.md#Pollable-readiness> +// for a more information. +// +// Note: this function is here for WASI Preview2 only. +// It's planned to be removed when `future` is natively supported in Preview3. +extern tcp_own_pollable_t tcp_method_tcp_socket_subscribe(tcp_borrow_tcp_socket_t self); +// Initiate a graceful shutdown. +// +// - `receive`: The socket is not expecting to receive any data from +// the peer. The `input-stream` associated with this socket will be +// closed. Any data still in the receive queue at time of calling +// this method will be discarded. +// - `send`: The socket has no more data to send to the peer. The `output-stream` +// associated with this socket will be closed and a FIN packet will be sent. +// - `both`: Same effect as `receive` & `send` combined. +// +// This function is idempotent. Shutting a down a direction more than once +// has no effect and returns `ok`. +// +// The shutdown function does not close (drop) the socket. +// +// # Typical errors +// - `invalid-state`: The socket is not in the `connected` state. (ENOTCONN) +// +// # References +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/shutdown.html> +// - <https://man7.org/linux/man-pages/man2/shutdown.2.html> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-shutdown> +// - <https://man.freebsd.org/cgi/man.cgi?query=shutdown&sektion=2> +extern bool tcp_method_tcp_socket_shutdown(tcp_borrow_tcp_socket_t self, tcp_shutdown_type_t shutdown_type, tcp_error_code_t *err); + +// Imported Functions from `wasi:sockets/tcp-create-socket@0.2.0` +// Create a new TCP socket. +// +// Similar to `socket(AF_INET or AF_INET6, SOCK_STREAM, IPPROTO_TCP)` in POSIX. +// On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise. +// +// This function does not require a network capability handle. This is considered to be safe because +// at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind`/`connect` +// is called, the socket is effectively an in-memory configuration object, unable to communicate with the outside world. +// +// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations. +// +// # Typical errors +// - `not-supported`: The specified `address-family` is not supported. (EAFNOSUPPORT) +// - `new-socket-limit`: The new socket resource could not be created because of a system limit. (EMFILE, ENFILE) +// +// # References +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html> +// - <https://man7.org/linux/man-pages/man2/socket.2.html> +// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw> +// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2> +extern bool tcp_create_socket_create_tcp_socket(tcp_create_socket_ip_address_family_t address_family, tcp_create_socket_own_tcp_socket_t *ret, tcp_create_socket_error_code_t *err); + +// Imported Functions from `wasi:sockets/ip-name-lookup@0.2.0` +// Resolve an internet host name to a list of IP addresses. +// +// Unicode domain names are automatically converted to ASCII using IDNA encoding. +// If the input is an IP address string, the address is parsed and returned +// as-is without making any external requests. +// +// See the wasi-socket proposal README.md for a comparison with getaddrinfo. +// +// This function never blocks. It either immediately fails or immediately +// returns successfully with a `resolve-address-stream` that can be used +// to (asynchronously) fetch the results. +// +// # Typical errors +// - `invalid-argument`: `name` is a syntactically invalid domain name or IP address. +// +// # References: +// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html> +// - <https://man7.org/linux/man-pages/man3/getaddrinfo.3.html> +// - <https://learn.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo> +// - <https://man.freebsd.org/cgi/man.cgi?query=getaddrinfo&sektion=3> +extern bool ip_name_lookup_resolve_addresses(ip_name_lookup_borrow_network_t network, wasip2_string_t *name, ip_name_lookup_own_resolve_address_stream_t *ret, ip_name_lookup_error_code_t *err); +// Returns the next address from the resolver. +// +// This function should be called multiple times. On each call, it will +// return the next address in connection order preference. If all +// addresses have been exhausted, this function returns `none`. +// +// This function never returns IPv4-mapped IPv6 addresses. +// +// # Typical errors +// - `name-unresolvable`: Name does not exist or has no suitable associated IP addresses. (EAI_NONAME, EAI_NODATA, EAI_ADDRFAMILY) +// - `temporary-resolver-failure`: A temporary failure in name resolution occurred. (EAI_AGAIN) +// - `permanent-resolver-failure`: A permanent failure in name resolution occurred. (EAI_FAIL) +// - `would-block`: A result is not available yet. (EWOULDBLOCK, EAGAIN) +extern bool ip_name_lookup_method_resolve_address_stream_resolve_next_address(ip_name_lookup_borrow_resolve_address_stream_t self, ip_name_lookup_option_ip_address_t *ret, ip_name_lookup_error_code_t *err); +// Create a `pollable` which will resolve once the stream is ready for I/O. +// +// Note: this function is here for WASI Preview2 only. +// It's planned to be removed when `future` is natively supported in Preview3. +extern ip_name_lookup_own_pollable_t ip_name_lookup_method_resolve_address_stream_subscribe(ip_name_lookup_borrow_resolve_address_stream_t self); + +// Imported Functions from `wasi:random/random@0.2.0` +// Return `len` cryptographically-secure random or pseudo-random bytes. +// +// This function must produce data at least as cryptographically secure and +// fast as an adequately seeded cryptographically-secure pseudo-random +// number generator (CSPRNG). It must not block, from the perspective of +// the calling program, under any circumstances, including on the first +// request and on requests for numbers of bytes. The returned data must +// always be unpredictable. +// +// This function must always return fresh data. Deterministic environments +// must omit this function, rather than implementing it with deterministic +// data. +extern void random_get_random_bytes(uint64_t len, wasip2_list_u8_t *ret); +// Return a cryptographically-secure random or pseudo-random `u64` value. +// +// This function returns the same type of data as `get-random-bytes`, +// represented as a `u64`. +extern uint64_t random_get_random_u64(void); + +// Imported Functions from `wasi:random/insecure@0.2.0` +// Return `len` insecure pseudo-random bytes. +// +// This function is not cryptographically secure. Do not use it for +// anything related to security. +// +// There are no requirements on the values of the returned bytes, however +// implementations are encouraged to return evenly distributed values with +// a long period. +extern void random_insecure_get_insecure_random_bytes(uint64_t len, wasip2_list_u8_t *ret); +// Return an insecure pseudo-random `u64` value. +// +// This function returns the same type of pseudo-random data as +// `get-insecure-random-bytes`, represented as a `u64`. +extern uint64_t random_insecure_get_insecure_random_u64(void); + +// Imported Functions from `wasi:random/insecure-seed@0.2.0` +// Return a 128-bit value that may contain a pseudo-random value. +// +// The returned value is not required to be computed from a CSPRNG, and may +// even be entirely deterministic. Host implementations are encouraged to +// provide pseudo-random values to any program exposed to +// attacker-controlled content, to enable DoS protection built into many +// languages' hash-map implementations. +// +// This function is intended to only be called once, by a source language +// to initialize Denial Of Service (DoS) protection in its hash-map +// implementation. +// +// # Expected future evolution +// +// This will likely be changed to a value import, to prevent it from being +// called multiple times and potentially used for purposes other than DoS +// protection. +extern void random_insecure_seed_insecure_seed(wasip2_tuple2_u64_u64_t *ret); + +// Helper Functions + +void wasip2_tuple2_string_string_free(wasip2_tuple2_string_string_t *ptr); + +void wasip2_list_tuple2_string_string_free(wasip2_list_tuple2_string_string_t *ptr); + +void wasip2_list_string_free(wasip2_list_string_t *ptr); + +void wasip2_option_string_free(wasip2_option_string_t *ptr); + +void exit_result_void_void_free(exit_result_void_void_t *ptr); + +extern void io_error_error_drop_own(io_error_own_error_t handle); + +extern void io_error_error_drop_borrow(io_error_borrow_error_t handle); + +extern io_error_borrow_error_t io_error_borrow_error(io_error_own_error_t handle); + +extern void poll_pollable_drop_own(poll_own_pollable_t handle); + +extern void poll_pollable_drop_borrow(poll_borrow_pollable_t handle); + +extern poll_borrow_pollable_t poll_borrow_pollable(poll_own_pollable_t handle); + +void poll_list_borrow_pollable_free(poll_list_borrow_pollable_t *ptr); + +void wasip2_list_u32_free(wasip2_list_u32_t *ptr); + +void streams_stream_error_free(streams_stream_error_t *ptr); + +extern void streams_input_stream_drop_own(streams_own_input_stream_t handle); + +extern void streams_input_stream_drop_borrow(streams_borrow_input_stream_t handle); + +extern streams_borrow_input_stream_t streams_borrow_input_stream(streams_own_input_stream_t handle); + +extern void streams_output_stream_drop_own(streams_own_output_stream_t handle); + +extern void streams_output_stream_drop_borrow(streams_borrow_output_stream_t handle); + +extern streams_borrow_output_stream_t streams_borrow_output_stream(streams_own_output_stream_t handle); + +void wasip2_list_u8_free(wasip2_list_u8_t *ptr); + +void streams_result_list_u8_stream_error_free(streams_result_list_u8_stream_error_t *ptr); + +void streams_result_u64_stream_error_free(streams_result_u64_stream_error_t *ptr); + +void streams_result_void_stream_error_free(streams_result_void_stream_error_t *ptr); + +extern void terminal_input_terminal_input_drop_own(terminal_input_own_terminal_input_t handle); + +extern void terminal_input_terminal_input_drop_borrow(terminal_input_borrow_terminal_input_t handle); + +extern terminal_input_borrow_terminal_input_t terminal_input_borrow_terminal_input(terminal_input_own_terminal_input_t handle); + +extern void terminal_output_terminal_output_drop_own(terminal_output_own_terminal_output_t handle); + +extern void terminal_output_terminal_output_drop_borrow(terminal_output_borrow_terminal_output_t handle); + +extern terminal_output_borrow_terminal_output_t terminal_output_borrow_terminal_output(terminal_output_own_terminal_output_t handle); + +void terminal_stdin_option_own_terminal_input_free(terminal_stdin_option_own_terminal_input_t *ptr); + +void terminal_stdout_option_own_terminal_output_free(terminal_stdout_option_own_terminal_output_t *ptr); + +void terminal_stderr_option_own_terminal_output_free(terminal_stderr_option_own_terminal_output_t *ptr); + +void filesystem_option_datetime_free(filesystem_option_datetime_t *ptr); + +void filesystem_descriptor_stat_free(filesystem_descriptor_stat_t *ptr); + +void filesystem_new_timestamp_free(filesystem_new_timestamp_t *ptr); + +void filesystem_directory_entry_free(filesystem_directory_entry_t *ptr); + +extern void filesystem_descriptor_drop_own(filesystem_own_descriptor_t handle); + +extern void filesystem_descriptor_drop_borrow(filesystem_borrow_descriptor_t handle); + +extern filesystem_borrow_descriptor_t filesystem_borrow_descriptor(filesystem_own_descriptor_t handle); + +extern void filesystem_directory_entry_stream_drop_own(filesystem_own_directory_entry_stream_t handle); + +extern void filesystem_directory_entry_stream_drop_borrow(filesystem_borrow_directory_entry_stream_t handle); + +extern filesystem_borrow_directory_entry_stream_t filesystem_borrow_directory_entry_stream(filesystem_own_directory_entry_stream_t handle); + +void filesystem_result_own_input_stream_error_code_free(filesystem_result_own_input_stream_error_code_t *ptr); + +void filesystem_result_own_output_stream_error_code_free(filesystem_result_own_output_stream_error_code_t *ptr); + +void filesystem_result_void_error_code_free(filesystem_result_void_error_code_t *ptr); + +void filesystem_result_descriptor_flags_error_code_free(filesystem_result_descriptor_flags_error_code_t *ptr); + +void filesystem_result_descriptor_type_error_code_free(filesystem_result_descriptor_type_error_code_t *ptr); + +void filesystem_result_tuple2_list_u8_bool_error_code_free(filesystem_result_tuple2_list_u8_bool_error_code_t *ptr); + +void filesystem_result_filesize_error_code_free(filesystem_result_filesize_error_code_t *ptr); + +void filesystem_result_own_directory_entry_stream_error_code_free(filesystem_result_own_directory_entry_stream_error_code_t *ptr); + +void filesystem_result_descriptor_stat_error_code_free(filesystem_result_descriptor_stat_error_code_t *ptr); + +void filesystem_result_own_descriptor_error_code_free(filesystem_result_own_descriptor_error_code_t *ptr); + +void filesystem_result_string_error_code_free(filesystem_result_string_error_code_t *ptr); + +void filesystem_result_metadata_hash_value_error_code_free(filesystem_result_metadata_hash_value_error_code_t *ptr); + +void filesystem_option_directory_entry_free(filesystem_option_directory_entry_t *ptr); + +void filesystem_result_option_directory_entry_error_code_free(filesystem_result_option_directory_entry_error_code_t *ptr); + +void filesystem_option_error_code_free(filesystem_option_error_code_t *ptr); + +void filesystem_preopens_tuple2_own_descriptor_string_free(filesystem_preopens_tuple2_own_descriptor_string_t *ptr); + +void filesystem_preopens_list_tuple2_own_descriptor_string_free(filesystem_preopens_list_tuple2_own_descriptor_string_t *ptr); + +extern void network_network_drop_own(network_own_network_t handle); + +extern void network_network_drop_borrow(network_borrow_network_t handle); + +extern network_borrow_network_t network_borrow_network(network_own_network_t handle); + +void network_ip_address_free(network_ip_address_t *ptr); + +void network_ip_socket_address_free(network_ip_socket_address_t *ptr); + +void udp_ip_socket_address_free(udp_ip_socket_address_t *ptr); + +void udp_incoming_datagram_free(udp_incoming_datagram_t *ptr); + +void udp_option_ip_socket_address_free(udp_option_ip_socket_address_t *ptr); + +void udp_outgoing_datagram_free(udp_outgoing_datagram_t *ptr); + +extern void udp_udp_socket_drop_own(udp_own_udp_socket_t handle); + +extern void udp_udp_socket_drop_borrow(udp_borrow_udp_socket_t handle); + +extern udp_borrow_udp_socket_t udp_borrow_udp_socket(udp_own_udp_socket_t handle); + +extern void udp_incoming_datagram_stream_drop_own(udp_own_incoming_datagram_stream_t handle); + +extern void udp_incoming_datagram_stream_drop_borrow(udp_borrow_incoming_datagram_stream_t handle); + +extern udp_borrow_incoming_datagram_stream_t udp_borrow_incoming_datagram_stream(udp_own_incoming_datagram_stream_t handle); + +extern void udp_outgoing_datagram_stream_drop_own(udp_own_outgoing_datagram_stream_t handle); + +extern void udp_outgoing_datagram_stream_drop_borrow(udp_borrow_outgoing_datagram_stream_t handle); + +extern udp_borrow_outgoing_datagram_stream_t udp_borrow_outgoing_datagram_stream(udp_own_outgoing_datagram_stream_t handle); + +void udp_result_void_error_code_free(udp_result_void_error_code_t *ptr); + +void udp_result_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_error_code_free(udp_result_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_error_code_t *ptr); + +void udp_result_ip_socket_address_error_code_free(udp_result_ip_socket_address_error_code_t *ptr); + +void udp_result_u8_error_code_free(udp_result_u8_error_code_t *ptr); + +void udp_result_u64_error_code_free(udp_result_u64_error_code_t *ptr); + +void udp_list_incoming_datagram_free(udp_list_incoming_datagram_t *ptr); + +void udp_result_list_incoming_datagram_error_code_free(udp_result_list_incoming_datagram_error_code_t *ptr); + +void udp_list_outgoing_datagram_free(udp_list_outgoing_datagram_t *ptr); + +void udp_create_socket_result_own_udp_socket_error_code_free(udp_create_socket_result_own_udp_socket_error_code_t *ptr); + +void tcp_ip_socket_address_free(tcp_ip_socket_address_t *ptr); + +extern void tcp_tcp_socket_drop_own(tcp_own_tcp_socket_t handle); + +extern void tcp_tcp_socket_drop_borrow(tcp_borrow_tcp_socket_t handle); + +extern tcp_borrow_tcp_socket_t tcp_borrow_tcp_socket(tcp_own_tcp_socket_t handle); + +void tcp_result_void_error_code_free(tcp_result_void_error_code_t *ptr); + +void tcp_result_tuple2_own_input_stream_own_output_stream_error_code_free(tcp_result_tuple2_own_input_stream_own_output_stream_error_code_t *ptr); + +void tcp_result_tuple3_own_tcp_socket_own_input_stream_own_output_stream_error_code_free(tcp_result_tuple3_own_tcp_socket_own_input_stream_own_output_stream_error_code_t *ptr); + +void tcp_result_ip_socket_address_error_code_free(tcp_result_ip_socket_address_error_code_t *ptr); + +void tcp_result_bool_error_code_free(tcp_result_bool_error_code_t *ptr); + +void tcp_result_duration_error_code_free(tcp_result_duration_error_code_t *ptr); + +void tcp_result_u32_error_code_free(tcp_result_u32_error_code_t *ptr); + +void tcp_result_u8_error_code_free(tcp_result_u8_error_code_t *ptr); + +void tcp_result_u64_error_code_free(tcp_result_u64_error_code_t *ptr); + +void tcp_create_socket_result_own_tcp_socket_error_code_free(tcp_create_socket_result_own_tcp_socket_error_code_t *ptr); + +void ip_name_lookup_ip_address_free(ip_name_lookup_ip_address_t *ptr); + +extern void ip_name_lookup_resolve_address_stream_drop_own(ip_name_lookup_own_resolve_address_stream_t handle); + +extern void ip_name_lookup_resolve_address_stream_drop_borrow(ip_name_lookup_borrow_resolve_address_stream_t handle); + +extern ip_name_lookup_borrow_resolve_address_stream_t ip_name_lookup_borrow_resolve_address_stream(ip_name_lookup_own_resolve_address_stream_t handle); + +void ip_name_lookup_result_own_resolve_address_stream_error_code_free(ip_name_lookup_result_own_resolve_address_stream_error_code_t *ptr); + +void ip_name_lookup_option_ip_address_free(ip_name_lookup_option_ip_address_t *ptr); + +void ip_name_lookup_result_option_ip_address_error_code_free(ip_name_lookup_result_option_ip_address_error_code_t *ptr); + +// Transfers ownership of `s` into the string `ret` +void wasip2_string_set(wasip2_string_t *ret, char*s); + +// Creates a copy of the input nul-terminate string `s` and +// stores it into the component model string `ret`. +void wasip2_string_dup(wasip2_string_t *ret, const char*s); + +// Deallocates the string pointed to by `ret`, deallocating +// the memory behind the string. +void wasip2_string_free(wasip2_string_t *ret); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/libc-bottom-half/signal/signal.c b/libc-bottom-half/signal/signal.c index 290d6b2..c9a435b 100644 --- a/libc-bottom-half/signal/signal.c +++ b/libc-bottom-half/signal/signal.c @@ -30,13 +30,13 @@ static void core_handler(int sig) { _Noreturn static void terminate_handler(int sig) { - fprintf(stderr, "Program recieved termination signal: %s\n", strsignal(sig)); + fprintf(stderr, "Program received termination signal: %s\n", strsignal(sig)); abort(); } _Noreturn static void stop_handler(int sig) { - fprintf(stderr, "Program recieved stop signal: %s\n", strsignal(sig)); + fprintf(stderr, "Program received stop signal: %s\n", strsignal(sig)); abort(); } diff --git a/libc-bottom-half/sources/__main_void.c b/libc-bottom-half/sources/__main_void.c index cba22ef..9f46419 100644 --- a/libc-bottom-half/sources/__main_void.c +++ b/libc-bottom-half/sources/__main_void.c @@ -3,11 +3,22 @@ #include <sysexits.h> // The user's `main` function, expecting arguments. +// +// Note that we make this a weak symbol so that it will have a +// `WASM_SYM_BINDING_WEAK` flag in libc.so, which tells the dynamic linker that +// it need not be defined (e.g. in reactor-style apps with no main function). +// See also the TODO comment on `__main_void` below. +__attribute__((__weak__)) int __main_argc_argv(int argc, char *argv[]); // If the user's `main` function expects arguments, the compiler will rename // it to `__main_argc_argv`, and this version will get linked in, which // initializes the argument data and calls `__main_argc_argv`. +// +// TODO: Ideally this function would be defined in a crt*.o file and linked in +// as necessary by the Clang driver. However, moving it to crt1-command.c +// breaks `--no-gc-sections`, so we'll probably need to create a new file +// (e.g. crt0.o or crtend.o) and teach Clang to use it when needed. __attribute__((__weak__, nodebug)) int __main_void(void) { __wasi_errno_t err; diff --git a/libc-bottom-half/sources/__wasilibc_fd_renumber.c b/libc-bottom-half/sources/__wasilibc_fd_renumber.c index 47992e9..7690d13 100644 --- a/libc-bottom-half/sources/__wasilibc_fd_renumber.c +++ b/libc-bottom-half/sources/__wasilibc_fd_renumber.c @@ -15,10 +15,85 @@ int __wasilibc_fd_renumber(int fd, int newfd) { return 0; } +#ifdef __wasilibc_use_wasip2 +#include <wasi/descriptor_table.h> + +void drop_tcp_socket(tcp_socket_t socket) { + switch (socket.state.tag) { + case TCP_SOCKET_STATE_UNBOUND: + case TCP_SOCKET_STATE_BOUND: + case TCP_SOCKET_STATE_CONNECTING: + case TCP_SOCKET_STATE_LISTENING: + case TCP_SOCKET_STATE_CONNECT_FAILED: + // No additional resources to drop. + break; + case TCP_SOCKET_STATE_CONNECTED: { + tcp_socket_state_connected_t connection = socket.state.connected; + + poll_pollable_drop_own(connection.input_pollable); + poll_pollable_drop_own(connection.output_pollable); + streams_input_stream_drop_own(connection.input); + streams_output_stream_drop_own(connection.output); + break; + } + default: /* unreachable */ abort(); + } + + poll_pollable_drop_own(socket.socket_pollable); + tcp_tcp_socket_drop_own(socket.socket); +} + +void drop_udp_socket_streams(udp_socket_streams_t streams) { + poll_pollable_drop_own(streams.incoming_pollable); + poll_pollable_drop_own(streams.outgoing_pollable); + udp_incoming_datagram_stream_drop_own(streams.incoming); + udp_outgoing_datagram_stream_drop_own(streams.outgoing); +} + +void drop_udp_socket(udp_socket_t socket) { + switch (socket.state.tag) { + case UDP_SOCKET_STATE_UNBOUND: + case UDP_SOCKET_STATE_BOUND_NOSTREAMS: + // No additional resources to drop. + break; + case UDP_SOCKET_STATE_BOUND_STREAMING: + drop_udp_socket_streams(socket.state.bound_streaming.streams); + break; + case UDP_SOCKET_STATE_CONNECTED: { + drop_udp_socket_streams(socket.state.connected.streams); + break; + } + default: /* unreachable */ abort(); + } + + poll_pollable_drop_own(socket.socket_pollable); + udp_udp_socket_drop_own(socket.socket); +} +#endif // __wasilibc_use_wasip2 + int close(int fd) { // Scan the preopen fds before making any changes. __wasilibc_populate_preopens(); +#ifdef __wasilibc_use_wasip2 + descriptor_table_entry_t entry; + if (descriptor_table_remove(fd, &entry)) { + + switch (entry.tag) + { + case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET: + drop_tcp_socket(entry.tcp_socket); + break; + case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET: + drop_udp_socket(entry.udp_socket); + break; + default: /* unreachable */ abort(); + } + + return 0; + } +#endif // __wasilibc_use_wasip2 + __wasi_errno_t error = __wasi_fd_close(fd); if (error != 0) { errno = error; diff --git a/libc-bottom-half/sources/accept.c b/libc-bottom-half/sources/accept-wasip1.c index 902e731..902e731 100644 --- a/libc-bottom-half/sources/accept.c +++ b/libc-bottom-half/sources/accept-wasip1.c diff --git a/libc-bottom-half/sources/accept-wasip2.c b/libc-bottom-half/sources/accept-wasip2.c new file mode 100644 index 0000000..3675958 --- /dev/null +++ b/libc-bottom-half/sources/accept-wasip2.c @@ -0,0 +1,143 @@ +#include <sys/socket.h> + +#include <errno.h> +#include <netinet/in.h> +#include <string.h> + +#include <wasi/api.h> +#include <wasi/descriptor_table.h> +#include <wasi/sockets_utils.h> + +int tcp_accept(tcp_socket_t *socket, bool client_blocking, + struct sockaddr *addr, socklen_t *addrlen) +{ + output_sockaddr_t output_addr; + if (!__wasi_sockets_utils__output_addr_validate( + socket->family, addr, addrlen, &output_addr)) { + errno = EINVAL; + return -1; + } + + tcp_socket_state_listening_t listener; + if (socket->state.tag == TCP_SOCKET_STATE_LISTENING) { + listener = socket->state.listening; + } else { + errno = EINVAL; + return -1; + } + + tcp_borrow_tcp_socket_t socket_borrow = + tcp_borrow_tcp_socket(socket->socket); + + tcp_tuple3_own_tcp_socket_own_input_stream_own_output_stream_t + client_and_io; + network_error_code_t error; + while (!tcp_method_tcp_socket_accept(socket_borrow, &client_and_io, + &error)) { + if (error == NETWORK_ERROR_CODE_WOULD_BLOCK) { + if (socket->blocking) { + poll_borrow_pollable_t pollable_borrow = + poll_borrow_pollable( + socket->socket_pollable); + poll_method_pollable_block(pollable_borrow); + } else { + errno = EWOULDBLOCK; + return -1; + } + } else { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + } + + tcp_own_tcp_socket_t client = client_and_io.f0; + tcp_borrow_tcp_socket_t client_borrow = tcp_borrow_tcp_socket(client); + + poll_own_pollable_t client_pollable = + tcp_method_tcp_socket_subscribe(client_borrow); + + streams_own_input_stream_t input = client_and_io.f1; + streams_borrow_input_stream_t input_borrow = + streams_borrow_input_stream(input); + poll_own_pollable_t input_pollable = + streams_method_input_stream_subscribe(input_borrow); + + streams_own_output_stream_t output = client_and_io.f2; + streams_borrow_output_stream_t output_borrow = + streams_borrow_output_stream(output); + poll_own_pollable_t output_pollable = + streams_method_output_stream_subscribe(output_borrow); + + if (output_addr.tag != OUTPUT_SOCKADDR_NULL) { + network_ip_socket_address_t remote_address; + if (!tcp_method_tcp_socket_remote_address( + client_borrow, &remote_address, &error)) { + // TODO wasi-sockets: How to recover from this in a POSIX compatible way? + abort(); + } + + __wasi_sockets_utils__output_addr_write(remote_address, + &output_addr); + } + + descriptor_table_entry_t client_entry = { .tag = DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET, .tcp_socket = { + .socket = client, + .socket_pollable = client_pollable, + .blocking = client_blocking, + .fake_nodelay = socket->fake_nodelay, + .family = socket->family, + .state = { .tag = TCP_SOCKET_STATE_CONNECTED, .connected = { + .input = input, + .input_pollable = input_pollable, + .output = output, + .output_pollable = output_pollable, + } }, + } }; + + int client_fd; + if (!descriptor_table_insert(client_entry, &client_fd)) { + errno = EMFILE; + return -1; + } + + return client_fd; +} + +int udp_accept(udp_socket_t *socket, bool client_blocking, + struct sockaddr *addr, socklen_t *addrlen) +{ + // UDP doesn't support accept + errno = EOPNOTSUPP; + return -1; +} + +int accept(int socket, struct sockaddr *restrict addr, + socklen_t *restrict addrlen) +{ + return accept4(socket, addr, addrlen, 0); +} + +int accept4(int socket, struct sockaddr *restrict addr, + socklen_t *restrict addrlen, int flags) +{ + descriptor_table_entry_t *entry; + if (!descriptor_table_get_ref(socket, &entry)) { + errno = EBADF; + return -1; + } + + bool client_blocking = (flags & SOCK_NONBLOCK) == 0; + // Ignore SOCK_CLOEXEC flag. That concept does not exist in WASI. + + switch (entry->tag) { + case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET: + return tcp_accept(&entry->tcp_socket, client_blocking, addr, + addrlen); + case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET: + return udp_accept(&entry->udp_socket, client_blocking, addr, + addrlen); + default: + errno = EOPNOTSUPP; + return -1; + } +} diff --git a/libc-bottom-half/sources/bind.c b/libc-bottom-half/sources/bind.c new file mode 100644 index 0000000..6204691 --- /dev/null +++ b/libc-bottom-half/sources/bind.c @@ -0,0 +1,53 @@ +#include <errno.h> +#include <netinet/in.h> + +#include <wasi/api.h> +#include <wasi/descriptor_table.h> +#include <wasi/sockets_utils.h> + +int tcp_bind(tcp_socket_t *socket, const struct sockaddr *addr, + socklen_t addrlen) +{ + network_ip_socket_address_t local_address; + int parse_err; + if (!__wasi_sockets_utils__parse_address(socket->family, addr, addrlen, + &local_address, &parse_err)) { + errno = parse_err; + return -1; + } + + return __wasi_sockets_utils__tcp_bind(socket, &local_address); +} + +int udp_bind(udp_socket_t *socket, const struct sockaddr *addr, + socklen_t addrlen) +{ + network_ip_socket_address_t local_address; + int parse_err; + if (!__wasi_sockets_utils__parse_address(socket->family, addr, addrlen, + &local_address, &parse_err)) { + errno = parse_err; + return -1; + } + + return __wasi_sockets_utils__udp_bind(socket, &local_address); +} + +int bind(int socket, const struct sockaddr *addr, socklen_t addrlen) +{ + descriptor_table_entry_t *entry; + if (!descriptor_table_get_ref(socket, &entry)) { + errno = EBADF; + return -1; + } + + switch (entry->tag) { + case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET: + return tcp_bind(&entry->tcp_socket, addr, addrlen); + case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET: + return udp_bind(&entry->udp_socket, addr, addrlen); + default: + errno = EOPNOTSUPP; + return -1; + } +} diff --git a/libc-bottom-half/sources/connect.c b/libc-bottom-half/sources/connect.c new file mode 100644 index 0000000..7ef6808 --- /dev/null +++ b/libc-bottom-half/sources/connect.c @@ -0,0 +1,197 @@ +#include <errno.h> +#include <netinet/in.h> + +#include <wasi/descriptor_table.h> +#include <wasi/sockets_utils.h> + +static int tcp_connect(tcp_socket_t *socket, const struct sockaddr *addr, + socklen_t addrlen) +{ + network_ip_socket_address_t remote_address; + int parse_err; + if (!__wasi_sockets_utils__parse_address(socket->family, addr, addrlen, + &remote_address, &parse_err)) { + errno = parse_err; + return -1; + } + + switch (socket->state.tag) { + case TCP_SOCKET_STATE_UNBOUND: + case TCP_SOCKET_STATE_BOUND: + // These can initiate a connect. + break; + case TCP_SOCKET_STATE_CONNECTING: + errno = EALREADY; + return -1; + case TCP_SOCKET_STATE_CONNECTED: + errno = EISCONN; + return -1; + case TCP_SOCKET_STATE_CONNECT_FAILED: // POSIX: "If connect() fails, the state of the socket is unspecified. Conforming applications should close the file descriptor and create a new socket before attempting to reconnect." + case TCP_SOCKET_STATE_LISTENING: + default: + errno = EOPNOTSUPP; + return -1; + } + + network_error_code_t error; + network_borrow_network_t network_borrow = + __wasi_sockets_utils__borrow_network(); + tcp_borrow_tcp_socket_t socket_borrow = + tcp_borrow_tcp_socket(socket->socket); + + if (!tcp_method_tcp_socket_start_connect(socket_borrow, network_borrow, + &remote_address, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + // Connect has successfully started. + socket->state = (tcp_socket_state_t){ + .tag = TCP_SOCKET_STATE_CONNECTING, + .connecting = { /* No additional state */ } + }; + + // Attempt to finish it: + tcp_tuple2_own_input_stream_own_output_stream_t io; + while (!tcp_method_tcp_socket_finish_connect(socket_borrow, &io, + &error)) { + if (error == NETWORK_ERROR_CODE_WOULD_BLOCK) { + if (socket->blocking) { + poll_borrow_pollable_t pollable_borrow = + poll_borrow_pollable( + socket->socket_pollable); + poll_method_pollable_block(pollable_borrow); + } else { + errno = EINPROGRESS; + return -1; + } + } else { + socket->state = + (tcp_socket_state_t){ .tag = TCP_SOCKET_STATE_CONNECT_FAILED, + .connect_failed = { + .error_code = + error, + } }; + + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + } + + // Connect successful. + + streams_own_input_stream_t input = io.f0; + streams_borrow_input_stream_t input_borrow = + streams_borrow_input_stream(input); + poll_own_pollable_t input_pollable = + streams_method_input_stream_subscribe(input_borrow); + + streams_own_output_stream_t output = io.f1; + streams_borrow_output_stream_t output_borrow = + streams_borrow_output_stream(output); + poll_own_pollable_t output_pollable = + streams_method_output_stream_subscribe(output_borrow); + + socket->state = + (tcp_socket_state_t){ .tag = TCP_SOCKET_STATE_CONNECTED, + .connected = { + .input = input, + .input_pollable = input_pollable, + .output = output, + .output_pollable = + output_pollable, + } }; + return 0; +} + +// When `connect` is called on a UDP socket with an AF_UNSPEC address, it is actually a "disconnect" request. +static int udp_connect(udp_socket_t *socket, const struct sockaddr *addr, + socklen_t addrlen) +{ + if (addr == NULL || addrlen < sizeof(struct sockaddr)) { + errno = EINVAL; + return -1; + } + + network_ip_socket_address_t remote_address; + bool has_remote_address = (addr->sa_family != AF_UNSPEC); + if (has_remote_address) { + int parse_err; + if (!__wasi_sockets_utils__parse_address( + socket->family, addr, addrlen, &remote_address, + &parse_err)) { + errno = parse_err; + return -1; + } + } + + // Prepare the socket; binding it if not bound yet, and disconnecting it if connected. + switch (socket->state.tag) { + case UDP_SOCKET_STATE_UNBOUND: { + // Socket is not explicitly bound by the user. We'll do it for them: + + network_ip_socket_address_t any = + __wasi_sockets_utils__any_addr(socket->family); + int result = __wasi_sockets_utils__udp_bind(socket, &any); + if (result != 0) { + return result; + } + break; + } + case UDP_SOCKET_STATE_BOUND_NOSTREAMS: { + // This is the state we want to be in. + break; + } + case UDP_SOCKET_STATE_BOUND_STREAMING: { + __wasi_sockets_utils__drop_streams( + socket->state.bound_streaming.streams); + socket->state = (udp_socket_state_t){ + .tag = UDP_SOCKET_STATE_BOUND_NOSTREAMS, + .bound_nostreams = {} + }; + break; + } + case UDP_SOCKET_STATE_CONNECTED: { + __wasi_sockets_utils__drop_streams( + socket->state.connected.streams); + socket->state = (udp_socket_state_t){ + .tag = UDP_SOCKET_STATE_BOUND_NOSTREAMS, + .bound_nostreams = {} + }; + break; + } + default: /* unreachable */ + abort(); + } + + network_error_code_t error; + udp_socket_streams_t streams; + + if (!__wasi_sockets_utils__stream( + socket, has_remote_address ? &remote_address : NULL, + &streams, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + return 0; +} + +int connect(int fd, const struct sockaddr *addr, socklen_t addrlen) +{ + descriptor_table_entry_t *entry; + if (!descriptor_table_get_ref(fd, &entry)) { + errno = EBADF; + return -1; + } + + switch (entry->tag) { + case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET: + return tcp_connect(&entry->tcp_socket, addr, addrlen); + case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET: + return udp_connect(&entry->udp_socket, addr, addrlen); + default: + errno = EOPNOTSUPP; + return -1; + } +} diff --git a/libc-bottom-half/sources/descriptor_table.c b/libc-bottom-half/sources/descriptor_table.c new file mode 100644 index 0000000..d45e7ce --- /dev/null +++ b/libc-bottom-half/sources/descriptor_table.c @@ -0,0 +1,255 @@ +/* + * This file provides a global hashtable for tracking `wasi-libc`-managed file + * descriptors. + * + * WASI Preview 2 has no notion of file descriptors and instead uses unforgeable + * resource handles (which are currently represented as integers at the ABI + * level, used as indices into per-component tables managed by the host). + * Moreover, there's not necessarily a one-to-one correspondence between POSIX + * file descriptors and resource handles (e.g. a TCP connection may require + * separate handles for reading, writing, and polling the same connection). We + * use this table to map each POSIX descriptor to a set of one or more handles. + * + * As of this writing, we still rely on the WASI Preview 1 adapter + * (https://github.com/bytecodealliance/wasmtime/tree/main/crates/wasi-preview1-component-adapter) + * to manage non-socket descriptors, so currently this table only tracks TCP and + * UDP sockets. We use the adapter's `adapter_open_badfd` and + * `adapter_close_badfd` functions to reserve and later close descriptors to + * avoid confusion (e.g. if an application tries to use Preview 1 host functions + * directly for socket operations rather than go through `wasi-libc`). + * Eventually, we'll switch `wasi-libc` over to Preview 2 entirely, at which + * point we'll no longer need the adapter. At that point, all file descriptors + * will be managed exclusively in this table. + */ + +#include <wasi/descriptor_table.h> + +__attribute__((__import_module__("wasi_snapshot_preview1"), + __import_name__("adapter_open_badfd"))) extern int32_t + __wasi_preview1_adapter_open_badfd(int32_t); + +static bool wasi_preview1_adapter_open_badfd(int *fd) +{ + return __wasi_preview1_adapter_open_badfd((int32_t)fd) == 0; +} + +__attribute__((__import_module__("wasi_snapshot_preview1"), + __import_name__("adapter_close_badfd"))) extern int32_t + __wasi_preview1_adapter_close_badfd(int32_t); + +static bool wasi_preview1_adapter_close_badfd(int fd) +{ + return __wasi_preview1_adapter_close_badfd(fd) == 0; +} + +/* + * This hash table is based on the one in musl/src/search/hsearch.c, but uses + * integer keys and supports a `remove` operation. Note that I've switched from + * quadratic to linear probing in order to make `remove` simple and efficient, + * with the tradeoff that clustering is more likely. See also + * https://en.wikipedia.org/wiki/Open_addressing. + */ + +#define MINSIZE 8 +#define MAXSIZE ((size_t)-1 / 2 + 1) + +typedef struct { + bool occupied; + int key; + descriptor_table_entry_t entry; +} descriptor_table_item_t; + +typedef struct { + descriptor_table_item_t *entries; + size_t mask; + size_t used; +} descriptor_table_t; + +static descriptor_table_t global_table = { .entries = NULL, + .mask = 0, + .used = 0 }; + +static size_t keyhash(int key) +{ + // TODO: use a hash function here + return key; +} + +static int resize(size_t nel, descriptor_table_t *table) +{ + size_t newsize; + size_t i; + descriptor_table_item_t *e, *newe; + descriptor_table_item_t *oldtab = table->entries; + descriptor_table_item_t *oldend = table->entries + table->mask + 1; + + if (nel > MAXSIZE) + nel = MAXSIZE; + for (newsize = MINSIZE; newsize < nel; newsize *= 2) + ; + table->entries = calloc(newsize, sizeof *table->entries); + if (!table->entries) { + table->entries = oldtab; + return 0; + } + table->mask = newsize - 1; + if (!oldtab) + return 1; + for (e = oldtab; e < oldend; e++) + if (e->occupied) { + for (i = keyhash(e->key);; ++i) { + newe = table->entries + (i & table->mask); + if (!newe->occupied) + break; + } + *newe = *e; + } + free(oldtab); + return 1; +} + +static descriptor_table_item_t *lookup(int key, size_t hash, + descriptor_table_t *table) +{ + size_t i; + descriptor_table_item_t *e; + + for (i = hash;; ++i) { + e = table->entries + (i & table->mask); + if (!e->occupied || e->key == key) + break; + } + return e; +} + +static bool insert(descriptor_table_entry_t entry, int fd, + descriptor_table_t *table) +{ + if (!table->entries) { + if (!resize(MINSIZE, table)) { + return false; + } + } + + size_t hash = keyhash(fd); + descriptor_table_item_t *e = lookup(fd, hash, table); + + e->entry = entry; + if (!e->occupied) { + e->key = fd; + e->occupied = true; + if (++table->used > table->mask - table->mask / 4) { + if (!resize(2 * table->used, table)) { + table->used--; + e->occupied = false; + return false; + } + } + } + return true; +} + +static bool get(int fd, descriptor_table_entry_t **entry, + descriptor_table_t *table) +{ + if (!table->entries) { + return false; + } + + size_t hash = keyhash(fd); + descriptor_table_item_t *e = lookup(fd, hash, table); + if (e->occupied) { + *entry = &e->entry; + return true; + } else { + return false; + } +} + +static bool remove(int fd, descriptor_table_entry_t *entry, + descriptor_table_t *table) +{ + if (!table->entries) { + return false; + } + + size_t hash = keyhash(fd); + size_t i; + descriptor_table_item_t *e; + for (i = hash;; ++i) { + e = table->entries + (i & table->mask); + if (!e->occupied || e->key == fd) + break; + } + + if (e->occupied) { + *entry = e->entry; + e->occupied = false; + + // Search for any occupied entries which would be lost (due to + // an interrupted linear probe) if we left this one unoccupied + // and move them as necessary. + i = i & table->mask; + size_t j = i; + while (true) { + j = (j + 1) & table->mask; + e = table->entries + j; + if (!e->occupied) + break; + size_t k = keyhash(e->key) & table->mask; + if (i <= j) { + if ((i < k) && (k <= j)) + continue; + } else if ((i < k) || (k <= j)) { + continue; + } + table->entries[i] = *e; + e->occupied = false; + i = j; + } + + // If the load factor has dropped below 25%, shrink the table to + // reduce memory footprint. + if (--table->used < table->mask / 4) { + resize(table->mask / 2, table); + } + + return true; + } else { + return false; + } +} + +bool descriptor_table_insert(descriptor_table_entry_t entry, int *fd) +{ + if (wasi_preview1_adapter_open_badfd(fd)) { + if (insert(entry, *fd, &global_table)) { + return true; + } else { + if (!wasi_preview1_adapter_close_badfd(*fd)) { + abort(); + } + *fd = -1; + return false; + } + } else { + return false; + } +} + +bool descriptor_table_get_ref(int fd, descriptor_table_entry_t **entry) +{ + return get(fd, entry, &global_table); +} + +bool descriptor_table_remove(int fd, descriptor_table_entry_t *entry) +{ + if (remove(fd, entry, &global_table)) { + if (!wasi_preview1_adapter_close_badfd(fd)) { + abort(); + } + return true; + } else { + return false; + } +} diff --git a/libc-bottom-half/sources/getsockpeername.c b/libc-bottom-half/sources/getsockpeername.c new file mode 100644 index 0000000..463c233 --- /dev/null +++ b/libc-bottom-half/sources/getsockpeername.c @@ -0,0 +1,229 @@ +#include <errno.h> +#include <netinet/in.h> + +#include <wasi/descriptor_table.h> +#include <wasi/sockets_utils.h> + +int tcp_getsockname(tcp_socket_t *socket, struct sockaddr *addr, + socklen_t *addrlen) +{ + output_sockaddr_t output_addr; + if (!__wasi_sockets_utils__output_addr_validate( + socket->family, addr, addrlen, &output_addr)) { + errno = EINVAL; + return -1; + } + + if (output_addr.tag == OUTPUT_SOCKADDR_NULL) { + errno = EINVAL; + return -1; + } + + switch (socket->state.tag) { + case TCP_SOCKET_STATE_UNBOUND: + errno = EINVAL; + return -1; + + case TCP_SOCKET_STATE_BOUND: + case TCP_SOCKET_STATE_CONNECTING: + case TCP_SOCKET_STATE_CONNECT_FAILED: + case TCP_SOCKET_STATE_LISTENING: + case TCP_SOCKET_STATE_CONNECTED: + // OK. Continue.. + break; + + default: /* unreachable */ + abort(); + } + + network_error_code_t error; + network_ip_socket_address_t result; + tcp_borrow_tcp_socket_t socket_borrow = + tcp_borrow_tcp_socket(socket->socket); + if (!tcp_method_tcp_socket_local_address(socket_borrow, &result, + &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + __wasi_sockets_utils__output_addr_write(result, &output_addr); + + return 0; +} + +int tcp_getpeername(tcp_socket_t *socket, struct sockaddr *addr, + socklen_t *addrlen) +{ + output_sockaddr_t output_addr; + if (!__wasi_sockets_utils__output_addr_validate( + socket->family, addr, addrlen, &output_addr)) { + errno = EINVAL; + return -1; + } + + if (output_addr.tag == OUTPUT_SOCKADDR_NULL) { + errno = EINVAL; + return -1; + } + + switch (socket->state.tag) { + case TCP_SOCKET_STATE_UNBOUND: + case TCP_SOCKET_STATE_BOUND: + case TCP_SOCKET_STATE_CONNECTING: + case TCP_SOCKET_STATE_CONNECT_FAILED: + case TCP_SOCKET_STATE_LISTENING: + errno = ENOTCONN; + return -1; + + case TCP_SOCKET_STATE_CONNECTED: + // OK. Continue.. + break; + + default: /* unreachable */ + abort(); + } + + network_error_code_t error; + network_ip_socket_address_t result; + tcp_borrow_tcp_socket_t socket_borrow = + tcp_borrow_tcp_socket(socket->socket); + if (!tcp_method_tcp_socket_remote_address(socket_borrow, &result, + &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + __wasi_sockets_utils__output_addr_write(result, &output_addr); + + return 0; +} + +int udp_getsockname(udp_socket_t *socket, struct sockaddr *addr, + socklen_t *addrlen) +{ + output_sockaddr_t output_addr; + if (!__wasi_sockets_utils__output_addr_validate( + socket->family, addr, addrlen, &output_addr)) { + errno = EINVAL; + return -1; + } + + if (output_addr.tag == OUTPUT_SOCKADDR_NULL) { + errno = EINVAL; + return -1; + } + + switch (socket->state.tag) { + case UDP_SOCKET_STATE_UNBOUND: + errno = EINVAL; + return -1; + + case UDP_SOCKET_STATE_BOUND_NOSTREAMS: + case UDP_SOCKET_STATE_BOUND_STREAMING: + case UDP_SOCKET_STATE_CONNECTED: + // OK. Continue.. + break; + + default: /* unreachable */ + abort(); + } + + network_error_code_t error; + network_ip_socket_address_t result; + udp_borrow_udp_socket_t socket_borrow = + udp_borrow_udp_socket(socket->socket); + if (!udp_method_udp_socket_local_address(socket_borrow, &result, + &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + __wasi_sockets_utils__output_addr_write(result, &output_addr); + + return 0; +} + +int udp_getpeername(udp_socket_t *socket, struct sockaddr *addr, + socklen_t *addrlen) +{ + output_sockaddr_t output_addr; + if (!__wasi_sockets_utils__output_addr_validate( + socket->family, addr, addrlen, &output_addr)) { + errno = EINVAL; + return -1; + } + + if (output_addr.tag == OUTPUT_SOCKADDR_NULL) { + errno = EINVAL; + return -1; + } + + switch (socket->state.tag) { + case UDP_SOCKET_STATE_UNBOUND: + case UDP_SOCKET_STATE_BOUND_NOSTREAMS: + case UDP_SOCKET_STATE_BOUND_STREAMING: + errno = ENOTCONN; + return -1; + + case UDP_SOCKET_STATE_CONNECTED: + // OK. Continue.. + break; + + default: /* unreachable */ + abort(); + } + + network_error_code_t error; + network_ip_socket_address_t result; + udp_borrow_udp_socket_t socket_borrow = + udp_borrow_udp_socket(socket->socket); + if (!udp_method_udp_socket_remote_address(socket_borrow, &result, + &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + __wasi_sockets_utils__output_addr_write(result, &output_addr); + + return 0; +} + +int getsockname(int socket, struct sockaddr *__restrict addr, + socklen_t *__restrict addrlen) +{ + descriptor_table_entry_t *entry; + if (!descriptor_table_get_ref(socket, &entry)) { + errno = EBADF; + return -1; + } + + switch (entry->tag) { + case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET: + return tcp_getsockname(&entry->tcp_socket, addr, addrlen); + case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET: + return udp_getsockname(&entry->udp_socket, addr, addrlen); + default: + errno = EOPNOTSUPP; + return -1; + } +} + +int getpeername(int socket, struct sockaddr *__restrict addr, + socklen_t *__restrict addrlen) +{ + descriptor_table_entry_t *entry; + if (!descriptor_table_get_ref(socket, &entry)) { + errno = EBADF; + return -1; + } + + switch (entry->tag) { + case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET: + return tcp_getpeername(&entry->tcp_socket, addr, addrlen); + case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET: + return udp_getpeername(&entry->udp_socket, addr, addrlen); + default: + errno = EOPNOTSUPP; + return -1; + } +} diff --git a/libc-bottom-half/sources/listen.c b/libc-bottom-half/sources/listen.c new file mode 100644 index 0000000..29a064a --- /dev/null +++ b/libc-bottom-half/sources/listen.c @@ -0,0 +1,115 @@ +#include <errno.h> +#include <netinet/in.h> + +#include <wasi/api.h> +#include <wasi/descriptor_table.h> +#include <wasi/sockets_utils.h> + +int tcp_listen(tcp_socket_t *socket, int backlog) +{ + network_error_code_t error; + tcp_borrow_tcp_socket_t socket_borrow = + tcp_borrow_tcp_socket(socket->socket); + + switch (socket->state.tag) { + case TCP_SOCKET_STATE_UNBOUND: { + // Socket is not explicitly bound by the user. We'll do it for them: + + network_ip_socket_address_t any = + __wasi_sockets_utils__any_addr(socket->family); + int result = __wasi_sockets_utils__tcp_bind(socket, &any); + if (result != 0) { + return result; + } + + if (socket->state.tag != TCP_SOCKET_STATE_BOUND) { + abort(); + } + // Great! We'll continue below. + break; + } + case TCP_SOCKET_STATE_BOUND: + // Great! We'll continue below. + break; + case TCP_SOCKET_STATE_LISTENING: + // We can only update the backlog size. + break; + case TCP_SOCKET_STATE_CONNECTING: + case TCP_SOCKET_STATE_CONNECTED: + case TCP_SOCKET_STATE_CONNECT_FAILED: + default: + errno = EINVAL; + return -1; + } + + if (!tcp_method_tcp_socket_set_listen_backlog_size(socket_borrow, + backlog, &error)) { + abort(); // Our own state checks should've prevented this from happening. + } + + if (socket->state.tag == TCP_SOCKET_STATE_LISTENING) { + // Updating the backlog is all we had to do. + return 0; + } + + network_borrow_network_t network_borrow = + __wasi_sockets_utils__borrow_network(); + if (!tcp_method_tcp_socket_start_listen(socket_borrow, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + // Listen has successfully started. Attempt to finish it: + while (!tcp_method_tcp_socket_finish_listen(socket_borrow, &error)) { + if (error == NETWORK_ERROR_CODE_WOULD_BLOCK) { + poll_borrow_pollable_t pollable_borrow = + poll_borrow_pollable(socket->socket_pollable); + poll_method_pollable_block(pollable_borrow); + } else { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + } + + // Listen successful. + + socket->state = (tcp_socket_state_t){ + .tag = TCP_SOCKET_STATE_LISTENING, + .listening = { /* No additional state */ } + }; + return 0; +} + +int udp_listen(udp_socket_t *socket, int backlog) +{ + // UDP doesn't support listen + errno = EOPNOTSUPP; + return -1; +} + +int listen(int socket, int backlog) +{ + descriptor_table_entry_t *entry; + if (!descriptor_table_get_ref(socket, &entry)) { + errno = EBADF; + return -1; + } + + if (backlog < 0) { + // POSIX: + // > If listen() is called with a backlog argument value that is + // > less than 0, the function behaves as if it had been called + // > with a backlog argument value of 0. + backlog = 0; + } + + switch (entry->tag) { + case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET: + return tcp_listen(&entry->tcp_socket, backlog); + case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET: + return udp_listen(&entry->udp_socket, backlog); + default: + errno = EOPNOTSUPP; + return -1; + } +} diff --git a/libc-bottom-half/sources/netdb.c b/libc-bottom-half/sources/netdb.c new file mode 100644 index 0000000..c30a396 --- /dev/null +++ b/libc-bottom-half/sources/netdb.c @@ -0,0 +1,238 @@ +#include <netdb.h> +#include <errno.h> +#include <stdlib.h> + +#include <wasi/sockets_utils.h> + +_Thread_local int h_errno = 0; + +static int map_error(ip_name_lookup_error_code_t error) +{ + switch (error) { + case NETWORK_ERROR_CODE_OUT_OF_MEMORY: + return EAI_MEMORY; + case NETWORK_ERROR_CODE_NAME_UNRESOLVABLE: + return EAI_NONAME; + case NETWORK_ERROR_CODE_TEMPORARY_RESOLVER_FAILURE: + return EAI_AGAIN; + case NETWORK_ERROR_CODE_PERMANENT_RESOLVER_FAILURE: + return EAI_FAIL; + + default: + errno = __wasi_sockets_utils__map_error(error); + return EAI_SYSTEM; + } +} + +static int add_addr(ip_name_lookup_option_ip_address_t address, + const struct addrinfo *restrict hint, + struct addrinfo **restrict current, + struct addrinfo **restrict res) +{ + int family; + struct sockaddr *addr; + socklen_t addrlen; + switch (address.val.tag) { + case NETWORK_IP_ADDRESS_IPV4: { + if (hint && hint->ai_family != AF_UNSPEC && + hint->ai_family != AF_INET) { + return 0; + } + + network_ipv4_address_t ip = address.val.val.ipv4; + + family = PF_INET; + addrlen = sizeof(struct sockaddr_in); + addr = malloc(addrlen); + if (addr == NULL) { + freeaddrinfo(*res); + return EAI_MEMORY; + } + + struct sockaddr_in sockaddr = { + .sin_family = AF_INET, + .sin_port = 0, + .sin_addr = { .s_addr = ip.f0 | (ip.f1 << 8) | + (ip.f2 << 16) | (ip.f3 << 24) }, + }; + memcpy(addr, &sockaddr, addrlen); + break; + } + case NETWORK_IP_ADDRESS_IPV6: { + if (hint && hint->ai_family != AF_UNSPEC && + hint->ai_family != AF_INET6) { + return 0; + } + + network_ipv6_address_t ip = address.val.val.ipv6; + + family = PF_INET6; + addrlen = sizeof(struct sockaddr_in6); + addr = malloc(addrlen); + if (addr == NULL) { + freeaddrinfo(*res); + return EAI_MEMORY; + } + + struct sockaddr_in6 sockaddr = { + .sin6_family = AF_INET6, + .sin6_port = 0, + .sin6_addr = { + .s6_addr = { + ip.f0 >> 8, + ip.f0 & 0xFF, + ip.f1 >> 8, + ip.f1 & 0xFF, + ip.f2 >> 8, + ip.f2 & 0xFF, + ip.f3 >> 8, + ip.f3 & 0xFF, + ip.f4 >> 8, + ip.f4 & 0xFF, + ip.f5 >> 8, + ip.f5 & 0xFF, + ip.f6 >> 8, + ip.f6 & 0xFF, + ip.f7 >> 8, + ip.f7 & 0xFF, + } }, + .sin6_flowinfo = 0, + .sin6_scope_id = 0, + }; + memcpy(addr, &sockaddr, addrlen); + break; + } + default: /* unreachable */ + abort(); + } + + struct addrinfo *result = malloc(sizeof(struct addrinfo)); + if (result == NULL) { + freeaddrinfo(*res); + return EAI_MEMORY; + } + + *result = (struct addrinfo){ + .ai_family = family, + .ai_flags = 0, + .ai_socktype = SOCK_STREAM, + .ai_protocol = 0, + .ai_addrlen = addrlen, + .ai_addr = addr, + .ai_canonname = NULL, + .ai_next = NULL, + }; + + if (*current) { + (*current)->ai_next = result; + *current = result; + } else { + *current = result; + *res = result; + } + + return 0; +} + +int getaddrinfo(const char *restrict host, const char *restrict serv, + const struct addrinfo *restrict hint, + struct addrinfo **restrict res) +{ + if (host == NULL) { + host = "localhost"; + } + + *res = NULL; + struct addrinfo *current = NULL; + wasip2_string_t name = { .ptr = (uint8_t *)host, .len = strlen(host) }; + ip_name_lookup_own_resolve_address_stream_t stream; + ip_name_lookup_error_code_t error; + if (ip_name_lookup_resolve_addresses( + __wasi_sockets_utils__borrow_network(), &name, &stream, + &error)) { + ip_name_lookup_borrow_resolve_address_stream_t stream_borrow = + ip_name_lookup_borrow_resolve_address_stream(stream); + while (true) { + ip_name_lookup_option_ip_address_t address; + if (ip_name_lookup_method_resolve_address_stream_resolve_next_address( + stream_borrow, &address, &error)) { + if (address.is_some) { + int error = add_addr(address, hint, + ¤t, res); + if (error) { + return error; + } + } else { + return 0; + } + } else if (error == NETWORK_ERROR_CODE_WOULD_BLOCK) { + ip_name_lookup_own_pollable_t pollable = + ip_name_lookup_method_resolve_address_stream_subscribe( + stream_borrow); + poll_borrow_pollable_t pollable_borrow = + poll_borrow_pollable(pollable); + poll_method_pollable_block(pollable_borrow); + poll_pollable_drop_own(pollable); + } else { + freeaddrinfo(*res); + return map_error(error); + } + } + } else { + return map_error(error); + } +} + +void freeaddrinfo(struct addrinfo *p) +{ + while (p) { + struct addrinfo *next = p->ai_next; + free(p->ai_addr); + free(p); + p = next; + } +} + +int getnameinfo(const struct sockaddr *restrict sa, socklen_t salen, + char *restrict host, socklen_t hostlen, char *restrict serv, + socklen_t servlen, int flags) +{ + // TODO wasi-sockets + abort(); +} + +struct hostent *gethostbyname(const char *name) +{ + // TODO wasi-sockets + return NULL; +} + +struct hostent *gethostbyaddr(const void *addr, socklen_t len, int type) +{ + // TODO wasi-sockets + return NULL; +} + +const char *hstrerror(int err) +{ + // TODO wasi-sockets + return "hstrerror: TODO"; +} + +struct servent *getservbyname(const char *name, const char *proto) +{ + // TODO wasi-sockets + return NULL; +} + +struct servent *getservbyport(int port, const char *proto) +{ + // TODO wasi-sockets + return NULL; +} + +struct protoent *getprotobyname(const char *name) +{ + // TODO wasi-sockets + return NULL; +} diff --git a/libc-bottom-half/sources/poll-wasip2.c b/libc-bottom-half/sources/poll-wasip2.c new file mode 100644 index 0000000..be7809c --- /dev/null +++ b/libc-bottom-half/sources/poll-wasip2.c @@ -0,0 +1,257 @@ +#include <errno.h> +#include <poll.h> + +#include <wasi/descriptor_table.h> + +typedef struct { + poll_own_pollable_t pollable; + struct pollfd *pollfd; + descriptor_table_entry_t *entry; + short events; +} state_t; + +int poll_wasip2(struct pollfd *fds, size_t nfds, int timeout) +{ + int event_count = 0; + for (size_t i = 0; i < nfds; ++i) { + fds[i].revents = 0; + } + + size_t max_pollables = (2 * nfds) + 1; + state_t states[max_pollables]; + size_t state_index = 0; + for (size_t i = 0; i < nfds; ++i) { + struct pollfd *pollfd = fds + i; + descriptor_table_entry_t *entry; + if (descriptor_table_get_ref(pollfd->fd, &entry)) { + switch (entry->tag) { + case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET: { + tcp_socket_t *socket = &(entry->tcp_socket); + switch (socket->state.tag) { + case TCP_SOCKET_STATE_CONNECTING: + case TCP_SOCKET_STATE_LISTENING: { + if ((pollfd->events & + (POLLRDNORM | POLLWRNORM)) != 0) { + states[state_index++] = (state_t){ + .pollable = + socket->socket_pollable, + .pollfd = pollfd, + .entry = entry, + .events = pollfd->events + }; + } + break; + } + + case TCP_SOCKET_STATE_CONNECTED: { + if ((pollfd->events & POLLRDNORM) != + 0) { + states[state_index++] = (state_t){ + .pollable = + socket->state + .connected + .input_pollable, + .pollfd = pollfd, + .entry = entry, + .events = POLLRDNORM + }; + } + if ((pollfd->events & POLLWRNORM) != + 0) { + states[state_index++] = (state_t){ + .pollable = + socket->state + .connected + .output_pollable, + .pollfd = pollfd, + .entry = entry, + .events = POLLWRNORM + }; + } + break; + } + + case TCP_SOCKET_STATE_CONNECT_FAILED: { + if (pollfd->revents == 0) { + ++event_count; + } + pollfd->revents |= pollfd->events; + break; + } + + default: + errno = ENOTSUP; + return -1; + } + break; + } + + case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET: { + udp_socket_t *socket = &(entry->udp_socket); + switch (socket->state.tag) { + case UDP_SOCKET_STATE_UNBOUND: + case UDP_SOCKET_STATE_BOUND_NOSTREAMS: { + if (pollfd->revents == 0) { + ++event_count; + } + pollfd->revents |= pollfd->events; + break; + } + + case UDP_SOCKET_STATE_BOUND_STREAMING: + case UDP_SOCKET_STATE_CONNECTED: { + udp_socket_streams_t *streams; + if (socket->state.tag == + UDP_SOCKET_STATE_BOUND_STREAMING) { + streams = &( + socket->state + .bound_streaming + .streams); + } else { + streams = &( + socket->state.connected + .streams); + } + if ((pollfd->events & POLLRDNORM) != + 0) { + states[state_index++] = (state_t){ + .pollable = + streams->incoming_pollable, + .pollfd = pollfd, + .entry = entry, + .events = POLLRDNORM + }; + } + if ((pollfd->events & POLLWRNORM) != + 0) { + states[state_index++] = (state_t){ + .pollable = + streams->outgoing_pollable, + .pollfd = pollfd, + .entry = entry, + .events = POLLWRNORM + }; + } + break; + } + + default: + errno = ENOTSUP; + return -1; + } + break; + } + + default: + errno = ENOTSUP; + return -1; + } + } else { + abort(); + } + } + + if (event_count > 0 && timeout != 0) { + return event_count; + } + + poll_borrow_pollable_t pollables[state_index + 1]; + for (size_t i = 0; i < state_index; ++i) { + pollables[i] = poll_borrow_pollable(states[i].pollable); + } + + poll_own_pollable_t timeout_pollable; + size_t pollable_count = state_index; + if (timeout >= 0) { + timeout_pollable = monotonic_clock_subscribe_duration( + ((monotonic_clock_duration_t)timeout) * 1000000); + pollables[pollable_count++] = + poll_borrow_pollable(timeout_pollable); + } + + wasip2_list_u32_t ready; + poll_list_borrow_pollable_t list = { + .ptr = (poll_borrow_pollable_t *)&pollables, + .len = pollable_count + }; + poll_poll(&list, &ready); + + for (size_t i = 0; i < ready.len; ++i) { + size_t index = ready.ptr[i]; + if (index < state_index) { + state_t *state = &states[index]; + if (state->entry->tag == + DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET && + state->entry->tcp_socket.state.tag == + TCP_SOCKET_STATE_CONNECTING) { + tcp_socket_t *socket = + &(state->entry->tcp_socket); + tcp_borrow_tcp_socket_t borrow = + tcp_borrow_tcp_socket(socket->socket); + tcp_tuple2_own_input_stream_own_output_stream_t + tuple; + tcp_error_code_t error; + if (tcp_method_tcp_socket_finish_connect( + borrow, &tuple, &error)) { + streams_borrow_input_stream_t + input_stream_borrow = + streams_borrow_input_stream( + tuple.f0); + streams_own_pollable_t input_pollable = + streams_method_input_stream_subscribe( + input_stream_borrow); + streams_borrow_output_stream_t + output_stream_borrow = + streams_borrow_output_stream( + tuple.f1); + streams_own_pollable_t output_pollable = + streams_method_output_stream_subscribe( + output_stream_borrow); + socket->state = + (tcp_socket_state_t){ .tag = TCP_SOCKET_STATE_CONNECTED, + .connected = { + .input_pollable = + input_pollable, + .input = + tuple.f0, + .output_pollable = + output_pollable, + .output = + tuple.f1, + } }; + if (state->pollfd->revents == 0) { + ++event_count; + } + state->pollfd->revents |= state->events; + } else if (error == + NETWORK_ERROR_CODE_WOULD_BLOCK) { + // No events yet -- application will need to poll again + } else { + socket->state = + (tcp_socket_state_t){ .tag = TCP_SOCKET_STATE_CONNECT_FAILED, + .connect_failed = { + .error_code = + error, + } }; + if (state->pollfd->revents == 0) { + ++event_count; + } + state->pollfd->revents |= state->events; + } + } else { + if (state->pollfd->revents == 0) { + ++event_count; + } + state->pollfd->revents |= state->events; + } + } + } + + wasip2_list_u32_free(&ready); + + if (timeout >= 0) { + poll_pollable_drop_own(timeout_pollable); + } + + return event_count; +} diff --git a/libc-bottom-half/sources/posix.c b/libc-bottom-half/sources/posix.c index b3e59ec..7da6a3d 100644 --- a/libc-bottom-half/sources/posix.c +++ b/libc-bottom-half/sources/posix.c @@ -6,6 +6,7 @@ #include <fcntl.h> #include <stdlib.h> #include <sys/stat.h> +#include <sys/statvfs.h> #include <unistd.h> #include <utime.h> #include <wasi/libc.h> @@ -310,6 +311,46 @@ int rename(const char *old, const char *new) { return -1; } +int chmod(const char *path, mode_t mode) { + // TODO: We plan to support this eventually in WASI, but not yet. + // Meanwhile, we provide a stub so that libc++'s `<filesystem>` + // implementation will build unmodified. + errno = ENOSYS; + return -1; +} + +int fchmod(int fd, mode_t mode) { + // TODO: We plan to support this eventually in WASI, but not yet. + // Meanwhile, we provide a stub so that libc++'s `<filesystem>` + // implementation will build unmodified. + errno = ENOSYS; + return -1; +} + +int fchmodat(int fd, const char *path, mode_t mode, int flag) { + // TODO: We plan to support this eventually in WASI, but not yet. + // Meanwhile, we provide a stub so that libc++'s `<filesystem>` + // implementation will build unmodified. + errno = ENOSYS; + return -1; +} + +int statvfs(const char *__restrict path, struct statvfs *__restrict buf) { + // TODO: We plan to support this eventually in WASI, but not yet. + // Meanwhile, we provide a stub so that libc++'s `<filesystem>` + // implementation will build unmodified. + errno = ENOSYS; + return -1; +} + +int fstatvfs(int fd, struct statvfs *buf) { + // TODO: We plan to support this eventually in WASI, but not yet. + // Meanwhile, we provide a stub so that libc++'s `<filesystem>` + // implementation will build unmodified. + errno = ENOSYS; + return -1; +} + // Like `access`, but with `faccessat`'s flags argument. int __wasilibc_access(const char *path, int mode, int flags) diff --git a/libc-bottom-half/sources/preopens.c b/libc-bottom-half/sources/preopens.c index b495433..3386ca4 100644 --- a/libc-bottom-half/sources/preopens.c +++ b/libc-bottom-half/sources/preopens.c @@ -260,7 +260,7 @@ void __wasilibc_populate_preopens(void) { if (prefix == NULL) goto software; - // TODO: Remove the cast on `path` once the witx is updated with + // TODO: Remove the cast on `prefix` once the witx is updated with // char8 support. ret = __wasi_fd_prestat_dir_name(fd, (uint8_t *)prefix, prestat.u.dir.pr_name_len); @@ -290,3 +290,23 @@ oserr: software: _Exit(EX_SOFTWARE); } + +void __wasilibc_reset_preopens(void) { + LOCK(lock); + + if (num_preopens) { + for (int i = 0; i < num_preopens; ++i) { + free((void*) preopens[i].prefix); + } + free(preopens); + } + + preopens_populated = false; + preopens = NULL; + num_preopens = 0; + preopen_capacity = 0; + + assert_invariants(); + + UNLOCK(lock); +} diff --git a/libc-bottom-half/sources/recv.c b/libc-bottom-half/sources/recv.c new file mode 100644 index 0000000..b9c3f4c --- /dev/null +++ b/libc-bottom-half/sources/recv.c @@ -0,0 +1,198 @@ +#include <sys/socket.h> + +#include <errno.h> +#include <stdint.h> + +#include <wasi/api.h> +#include <wasi/descriptor_table.h> +#include <wasi/sockets_utils.h> + +static ssize_t tcp_recvfrom(tcp_socket_t *socket, uint8_t *buffer, + size_t length, int flags, struct sockaddr *addr, + socklen_t *addrlen) +{ + // TODO wasi-sockets: flags: + // - MSG_WAITALL: we can probably support these relatively easy. + // - MSG_OOB: could be shimmed by always responding that no OOB data is available. + // - MSG_PEEK: could be shimmed by performing the receive into a local socket-specific buffer. And on subsequent receives first check that buffer. + + const int supported_flags = MSG_DONTWAIT; + if ((flags & supported_flags) != flags) { + errno = EOPNOTSUPP; + return -1; + } + + if (addr != NULL || addrlen != NULL) { + errno = EISCONN; + return -1; + } + + tcp_socket_state_connected_t connection; + if (socket->state.tag == TCP_SOCKET_STATE_CONNECTED) { + connection = socket->state.connected; + } else { + errno = ENOTCONN; + return -1; + } + + bool should_block = socket->blocking; + if ((flags & MSG_DONTWAIT) != 0) { + should_block = false; + } + + streams_borrow_input_stream_t rx_borrow = + streams_borrow_input_stream(connection.input); + while (true) { + wasip2_list_u8_t result; + streams_stream_error_t error; + if (!streams_method_input_stream_read(rx_borrow, length, + &result, &error)) { + if (error.tag == STREAMS_STREAM_ERROR_CLOSED) { + return 0; + } else { + // TODO wasi-sockets: wasi-sockets has no way to recover TCP stream errors yet. + errno = EPIPE; + return -1; + } + } + + if (result.len) { + memcpy(buffer, result.ptr, result.len); + wasip2_list_u8_free(&result); + return result.len; + } else if (should_block) { + poll_borrow_pollable_t pollable_borrow = + poll_borrow_pollable(connection.input_pollable); + poll_method_pollable_block(pollable_borrow); + } else { + errno = EWOULDBLOCK; + return -1; + } + } +} + +static ssize_t udp_recvfrom(udp_socket_t *socket, uint8_t *buffer, + size_t length, int flags, struct sockaddr *addr, + socklen_t *addrlen) +{ + // TODO wasi-sockets: flags: + // - MSG_PEEK: could be shimmed by performing the receive into a local socket-specific buffer. And on subsequent receives first check that buffer. + + const int supported_flags = MSG_DONTWAIT | MSG_TRUNC; + if ((flags & supported_flags) != flags) { + errno = EOPNOTSUPP; + return -1; + } + + output_sockaddr_t output_addr; + if (!__wasi_sockets_utils__output_addr_validate( + socket->family, addr, addrlen, &output_addr)) { + errno = EINVAL; + return -1; + } + + network_error_code_t error; + udp_borrow_udp_socket_t socket_borrow = + udp_borrow_udp_socket(socket->socket); + + udp_socket_streams_t streams; + switch (socket->state.tag) { + case UDP_SOCKET_STATE_UNBOUND: { + // Unlike `send`, `recv` should _not_ perform an implicit bind. + errno = EINVAL; + return -1; + } + case UDP_SOCKET_STATE_BOUND_NOSTREAMS: { + if (!__wasi_sockets_utils__stream(socket, NULL, &streams, + &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + break; + } + case UDP_SOCKET_STATE_BOUND_STREAMING: + streams = socket->state.bound_streaming.streams; + break; + + case UDP_SOCKET_STATE_CONNECTED: + streams = socket->state.connected.streams; + break; + + default: /* unreachable */ + abort(); + } + + bool return_real_size = (flags & MSG_TRUNC) != 0; + bool should_block = socket->blocking; + if ((flags & MSG_DONTWAIT) != 0) { + should_block = false; + } + + udp_borrow_incoming_datagram_stream_t incoming_borrow = + udp_borrow_incoming_datagram_stream(streams.incoming); + while (true) { + udp_list_incoming_datagram_t datagrams; + if (!udp_method_incoming_datagram_stream_receive( + incoming_borrow, 1, &datagrams, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + if (datagrams.len) { + udp_incoming_datagram_t datagram = datagrams.ptr[0]; + size_t datagram_size = datagram.data.len; + size_t bytes_to_copy = + datagram_size < length ? datagram_size : length; + + if (output_addr.tag != OUTPUT_SOCKADDR_NULL) { + __wasi_sockets_utils__output_addr_write( + datagram.remote_address, &output_addr); + } + + memcpy(buffer, datagram.data.ptr, bytes_to_copy); + udp_list_incoming_datagram_free(&datagrams); + return return_real_size ? datagram_size : bytes_to_copy; + + } else if (should_block) { + poll_borrow_pollable_t pollable_borrow = + poll_borrow_pollable(streams.incoming_pollable); + poll_method_pollable_block(pollable_borrow); + } else { + errno = EWOULDBLOCK; + return -1; + } + } +} + +ssize_t recv(int socket, void *restrict buffer, size_t length, int flags) +{ + return recvfrom(socket, buffer, length, flags, NULL, NULL); +} + +ssize_t recvfrom(int socket, void *__restrict buffer, size_t length, int flags, + struct sockaddr *__restrict addr, + socklen_t *__restrict addrlen) +{ + descriptor_table_entry_t *entry; + if (!descriptor_table_get_ref(socket, &entry)) { + errno = EBADF; + return -1; + } + + if (buffer == NULL) { + errno = EINVAL; + return -1; + } + + switch (entry->tag) { + case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET: + return tcp_recvfrom(&entry->tcp_socket, buffer, length, flags, + addr, addrlen); + case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET: + return udp_recvfrom(&entry->udp_socket, buffer, length, flags, + addr, addrlen); + default: + errno = EOPNOTSUPP; + return -1; + } +} diff --git a/libc-bottom-half/sources/send.c b/libc-bottom-half/sources/send.c new file mode 100644 index 0000000..42f653b --- /dev/null +++ b/libc-bottom-half/sources/send.c @@ -0,0 +1,249 @@ +#include <sys/socket.h> + +#include <errno.h> + +#include <wasi/api.h> +#include <wasi/descriptor_table.h> +#include <wasi/sockets_utils.h> + +static ssize_t tcp_sendto(tcp_socket_t *socket, const uint8_t *buffer, + size_t length, int flags, const struct sockaddr *addr, + socklen_t addrlen) +{ + const int supported_flags = MSG_DONTWAIT | MSG_NOSIGNAL; + if ((flags & supported_flags) != flags) { + errno = EOPNOTSUPP; + return -1; + } + + if (addr != NULL || addrlen != 0) { + errno = EISCONN; + return -1; + } + + tcp_socket_state_connected_t connection; + if (socket->state.tag == TCP_SOCKET_STATE_CONNECTED) { + connection = socket->state.connected; + } else { + errno = ENOTCONN; + return -1; + } + + bool should_block = socket->blocking; + if ((flags & MSG_DONTWAIT) != 0) { + should_block = false; + } + + if ((flags & MSG_NOSIGNAL) != 0) { + // Ignore it. WASI has no Unix-style signals. So effectively, + // MSG_NOSIGNAL is always the case, whether it was explicitly + // requested or not. + } + + streams_borrow_output_stream_t tx_borrow = + streams_borrow_output_stream(connection.output); + while (true) { + streams_stream_error_t error; + uint64_t count; + if (!streams_method_output_stream_check_write(tx_borrow, &count, + &error)) { + // TODO wasi-sockets: wasi-sockets has no way to recover stream errors yet. + errno = EPIPE; + return -1; + } + + if (count) { + count = count < length ? count : length; + wasip2_list_u8_t list = { .ptr = (uint8_t *)buffer, + .len = count }; + if (!streams_method_output_stream_write( + tx_borrow, &list, &error)) { + // TODO wasi-sockets: wasi-sockets has no way to recover TCP stream errors yet. + errno = EPIPE; + return -1; + } else { + return count; + } + } else if (should_block) { + poll_borrow_pollable_t pollable_borrow = + poll_borrow_pollable( + connection.output_pollable); + poll_method_pollable_block(pollable_borrow); + } else { + errno = EWOULDBLOCK; + return -1; + } + } +} + +static ssize_t udp_sendto(udp_socket_t *socket, const uint8_t *buffer, + size_t length, int flags, const struct sockaddr *addr, + socklen_t addrlen) +{ + const int supported_flags = MSG_DONTWAIT; + if ((flags & supported_flags) != flags) { + errno = EOPNOTSUPP; + return -1; + } + + network_ip_socket_address_t remote_address; + bool has_remote_address = (addr != NULL); + + if (has_remote_address) { + if (socket->state.tag == UDP_SOCKET_STATE_CONNECTED) { + errno = EISCONN; + return -1; + } + + int parse_err; + if (!__wasi_sockets_utils__parse_address( + socket->family, addr, addrlen, &remote_address, + &parse_err)) { + errno = parse_err; + return -1; + } + } else { + if (addrlen != 0) { + errno = EINVAL; + return -1; + } + + if (socket->state.tag != UDP_SOCKET_STATE_CONNECTED) { + errno = EDESTADDRREQ; + return -1; + } + } + + network_error_code_t error; + udp_borrow_udp_socket_t socket_borrow = + udp_borrow_udp_socket(socket->socket); + + udp_socket_streams_t streams; + switch (socket->state.tag) { + case UDP_SOCKET_STATE_UNBOUND: { + // Socket is not explicitly bound by the user. We'll do it for them: + + network_ip_socket_address_t any = + __wasi_sockets_utils__any_addr(socket->family); + int result = __wasi_sockets_utils__udp_bind(socket, &any); + if (result != 0) { + return result; + } + + if (!__wasi_sockets_utils__stream(socket, NULL, &streams, + &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + break; + } + case UDP_SOCKET_STATE_BOUND_NOSTREAMS: { + if (!__wasi_sockets_utils__stream(socket, NULL, &streams, + &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + break; + } + case UDP_SOCKET_STATE_BOUND_STREAMING: + streams = socket->state.bound_streaming.streams; + break; + + case UDP_SOCKET_STATE_CONNECTED: + streams = socket->state.connected.streams; + break; + + default: /* unreachable */ + abort(); + } + + bool should_block = socket->blocking; + if ((flags & MSG_DONTWAIT) != 0) { + should_block = false; + } + + udp_outgoing_datagram_t datagrams[1] = {{ + .remote_address = { + .is_some = has_remote_address, + .val = remote_address, + }, + .data = { + .len = length, + .ptr = (uint8_t*)buffer, + }, + }}; + udp_list_outgoing_datagram_t list = { + .len = 1, + .ptr = datagrams, + }; + + udp_borrow_outgoing_datagram_stream_t outgoing_borrow = + udp_borrow_outgoing_datagram_stream(streams.outgoing); + while (true) { + uint64_t allowed; + if (!udp_method_outgoing_datagram_stream_check_send( + outgoing_borrow, &allowed, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + if (allowed) { + uint64_t datagrams_sent; + if (!udp_method_outgoing_datagram_stream_send( + outgoing_borrow, &list, &datagrams_sent, + &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + if (datagrams_sent != 0 && datagrams_sent != 1) { + abort(); + } + + if (datagrams_sent == 1) { + return length; + } + } + + if (should_block) { + poll_borrow_pollable_t pollable_borrow = + poll_borrow_pollable(streams.outgoing_pollable); + poll_method_pollable_block(pollable_borrow); + } else { + errno = EWOULDBLOCK; + return -1; + } + } +} + +ssize_t send(int socket, const void *buffer, size_t length, int flags) +{ + return sendto(socket, buffer, length, flags, NULL, 0); +} + +ssize_t sendto(int socket, const void *buffer, size_t length, int flags, + const struct sockaddr *addr, socklen_t addrlen) +{ + descriptor_table_entry_t *entry; + if (!descriptor_table_get_ref(socket, &entry)) { + errno = EBADF; + return -1; + } + + if (buffer == NULL) { + errno = EINVAL; + return -1; + } + + switch (entry->tag) { + case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET: + return tcp_sendto(&entry->tcp_socket, buffer, length, flags, + addr, addrlen); + case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET: + return udp_sendto(&entry->udp_socket, buffer, length, flags, + addr, addrlen); + default: + errno = EOPNOTSUPP; + return -1; + } +} diff --git a/libc-bottom-half/sources/shutdown.c b/libc-bottom-half/sources/shutdown.c new file mode 100644 index 0000000..3ffd479 --- /dev/null +++ b/libc-bottom-half/sources/shutdown.c @@ -0,0 +1,80 @@ +#include <sys/socket.h> + +#include <errno.h> + +#include <wasi/api.h> +#include <wasi/descriptor_table.h> +#include <wasi/sockets_utils.h> + +int tcp_shutdown(tcp_socket_t *socket, int posix_how) +{ + tcp_shutdown_type_t wasi_how; + switch (posix_how) { + case SHUT_RD: + wasi_how = TCP_SHUTDOWN_TYPE_RECEIVE; + break; + case SHUT_WR: + wasi_how = TCP_SHUTDOWN_TYPE_SEND; + break; + case SHUT_RDWR: + wasi_how = TCP_SHUTDOWN_TYPE_BOTH; + break; + default: + errno = EINVAL; + return -1; + } + + tcp_socket_state_connected_t connection; + if (socket->state.tag == TCP_SOCKET_STATE_CONNECTED) { + connection = socket->state.connected; + } else { + errno = ENOTCONN; + return -1; + } + + network_error_code_t error; + tcp_borrow_tcp_socket_t socket_borrow = + tcp_borrow_tcp_socket(socket->socket); + if (!tcp_method_tcp_socket_shutdown(socket_borrow, wasi_how, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + if (posix_how == SHUT_RD || posix_how == SHUT_RDWR) { + // TODO wasi-sockets: drop input stream (if not already). And + // update `recv` to take dropped input streams into account. + } + + if (posix_how == SHUT_WR || posix_how == SHUT_RDWR) { + // TODO wasi-sockets: drop output stream (if not already). And + // update `send` to take dropped output streams into account. + } + + return 0; +} + +int udp_shutdown(udp_socket_t *socket, int posix_how) +{ + // UDP has nothing to shut down. + errno = EOPNOTSUPP; + return -1; +} + +int shutdown(int socket, int how) +{ + descriptor_table_entry_t *entry; + if (!descriptor_table_get_ref(socket, &entry)) { + errno = EBADF; + return -1; + } + + switch (entry->tag) { + case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET: + return tcp_shutdown(&entry->tcp_socket, how); + case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET: + return udp_shutdown(&entry->udp_socket, how); + default: + errno = EOPNOTSUPP; + return -1; + } +} diff --git a/libc-bottom-half/sources/socket.c b/libc-bottom-half/sources/socket.c new file mode 100644 index 0000000..3e61638 --- /dev/null +++ b/libc-bottom-half/sources/socket.c @@ -0,0 +1,107 @@ +#include <errno.h> +#include <netinet/in.h> + +#include <wasi/descriptor_table.h> +#include <wasi/sockets_utils.h> + +static int tcp_socket(network_ip_address_family_t family, bool blocking) +{ + tcp_create_socket_error_code_t error; + tcp_own_tcp_socket_t socket; + if (!tcp_create_socket_create_tcp_socket(family, &socket, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + tcp_borrow_tcp_socket_t socket_borrow = tcp_borrow_tcp_socket(socket); + poll_own_pollable_t socket_pollable = + tcp_method_tcp_socket_subscribe(socket_borrow); + + descriptor_table_entry_t + entry = { .tag = DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET, + .tcp_socket = { + .socket = socket, + .socket_pollable = socket_pollable, + .blocking = blocking, + .fake_nodelay = false, + .family = family, + .state = { .tag = TCP_SOCKET_STATE_UNBOUND, + .unbound = { + /* No additional state. */ } }, + } }; + + int fd; + if (!descriptor_table_insert(entry, &fd)) { + errno = EMFILE; + return -1; + } + return fd; +} + +static int udp_socket(network_ip_address_family_t family, bool blocking) +{ + udp_create_socket_error_code_t error; + udp_own_udp_socket_t socket; + if (!udp_create_socket_create_udp_socket(family, &socket, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + udp_borrow_udp_socket_t socket_borrow = udp_borrow_udp_socket(socket); + poll_own_pollable_t socket_pollable = + udp_method_udp_socket_subscribe(socket_borrow); + + descriptor_table_entry_t + entry = { .tag = DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET, + .udp_socket = { + .socket = socket, + .socket_pollable = socket_pollable, + .blocking = blocking, + .family = family, + .state = { .tag = UDP_SOCKET_STATE_UNBOUND, + .unbound = { + /* No additional state. */ } }, + } }; + + int fd; + if (!descriptor_table_insert(entry, &fd)) { + errno = EMFILE; + return -1; + } + return fd; +} + +int socket(int domain, int type, int protocol) +{ + network_ip_address_family_t family; + switch (domain) { + case PF_INET: + family = NETWORK_IP_ADDRESS_FAMILY_IPV4; + break; + + case PF_INET6: + family = NETWORK_IP_ADDRESS_FAMILY_IPV6; + break; + + default: + errno = EAFNOSUPPORT; + return -1; + } + + int real_type = type & ~(SOCK_NONBLOCK | SOCK_CLOEXEC); + bool blocking = (type & SOCK_NONBLOCK) == 0; + // Ignore SOCK_CLOEXEC flag. That concept does not exist in WASI. + + if (real_type == SOCK_STREAM && + (protocol == 0 || protocol == IPPROTO_TCP)) { + return tcp_socket(family, blocking); + + } else if (real_type == SOCK_DGRAM && + (protocol == 0 || protocol == IPPROTO_UDP)) { + return udp_socket(family, blocking); + + } else { + errno = EPROTONOSUPPORT; + return -1; + } +} diff --git a/libc-bottom-half/sources/sockets_utils.c b/libc-bottom-half/sources/sockets_utils.c new file mode 100644 index 0000000..4f5658a --- /dev/null +++ b/libc-bottom-half/sources/sockets_utils.c @@ -0,0 +1,462 @@ +#include <errno.h> + +#include <wasi/sockets_utils.h> + +static network_own_network_t global_network; +static bool global_network_initialized = false; + +network_borrow_network_t __wasi_sockets_utils__borrow_network() +{ + if (!global_network_initialized) { + global_network = instance_network_instance_network(); + global_network_initialized = true; + } + + return network_borrow_network(global_network); +} + +int __wasi_sockets_utils__map_error(network_error_code_t wasi_error) +{ + switch (wasi_error) { + case NETWORK_ERROR_CODE_ACCESS_DENIED: + return EACCES; + case NETWORK_ERROR_CODE_NOT_SUPPORTED: + return EOPNOTSUPP; + case NETWORK_ERROR_CODE_INVALID_ARGUMENT: + return EINVAL; + case NETWORK_ERROR_CODE_OUT_OF_MEMORY: + return ENOMEM; + case NETWORK_ERROR_CODE_TIMEOUT: + return ETIMEDOUT; + case NETWORK_ERROR_CODE_CONCURRENCY_CONFLICT: + return EALREADY; + case NETWORK_ERROR_CODE_WOULD_BLOCK: + return EWOULDBLOCK; + case NETWORK_ERROR_CODE_NEW_SOCKET_LIMIT: + return EMFILE; + case NETWORK_ERROR_CODE_ADDRESS_NOT_BINDABLE: + return EADDRNOTAVAIL; + case NETWORK_ERROR_CODE_ADDRESS_IN_USE: + return EADDRINUSE; + case NETWORK_ERROR_CODE_REMOTE_UNREACHABLE: + return EHOSTUNREACH; + case NETWORK_ERROR_CODE_CONNECTION_REFUSED: + return ECONNREFUSED; + case NETWORK_ERROR_CODE_CONNECTION_RESET: + return ECONNRESET; + case NETWORK_ERROR_CODE_CONNECTION_ABORTED: + return ECONNABORTED; + case NETWORK_ERROR_CODE_DATAGRAM_TOO_LARGE: + return EMSGSIZE; + + case NETWORK_ERROR_CODE_INVALID_STATE: + case NETWORK_ERROR_CODE_NOT_IN_PROGRESS: + abort(); // If our internal state checks are working right, these errors should never show up. + break; + + case NETWORK_ERROR_CODE_NAME_UNRESOLVABLE: + case NETWORK_ERROR_CODE_TEMPORARY_RESOLVER_FAILURE: + case NETWORK_ERROR_CODE_PERMANENT_RESOLVER_FAILURE: + abort(); // These errors are specific to getaddrinfo, which should have filtered these errors out before calling this generic method + break; + + case NETWORK_ERROR_CODE_UNKNOWN: + default: + return EOPNOTSUPP; + } +} + +bool __wasi_sockets_utils__parse_address( + network_ip_address_family_t expected_family, + const struct sockaddr *address, socklen_t len, + network_ip_socket_address_t *result, int *error) +{ + if (address == NULL || len < sizeof(struct sockaddr)) { + *error = EINVAL; + return false; + } + + switch (expected_family) { + case NETWORK_IP_ADDRESS_FAMILY_IPV4: { + if (address->sa_family != AF_INET) { + *error = EAFNOSUPPORT; + return false; + } + + if (len < sizeof(struct sockaddr_in)) { + *error = EINVAL; + return false; + } + + struct sockaddr_in *ipv4 = (struct sockaddr_in *)address; + unsigned ip = ipv4->sin_addr.s_addr; + unsigned short port = ipv4->sin_port; + *result = (network_ip_socket_address_t){ + .tag = NETWORK_IP_SOCKET_ADDRESS_IPV4, + .val = { .ipv4 = { + .port = ntohs(port), // (port << 8) | (port >> 8), + .address = { ip & 0xFF, (ip >> 8) & 0xFF, (ip >> 16) & 0xFF, ip >> 24 }, + } }, + }; + return true; + } + case NETWORK_IP_ADDRESS_FAMILY_IPV6: { + if (address->sa_family != AF_INET6) { + *error = EAFNOSUPPORT; + return false; + } + + if (len < sizeof(struct sockaddr_in6)) { + *error = EINVAL; + return false; + } + + struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)address; + unsigned char *ip = (unsigned char *)&(ipv6->sin6_addr.s6_addr); + unsigned short port = ipv6->sin6_port; + *result = (network_ip_socket_address_t){ + .tag = NETWORK_IP_SOCKET_ADDRESS_IPV6, + .val = { .ipv6 = { + .port = ntohs(port), + .address = { + (((unsigned short)ip[0]) << 8) | ip[1], + (((unsigned short)ip[2]) << 8) | ip[3], + (((unsigned short)ip[4]) << 8) | ip[5], + (((unsigned short)ip[6]) << 8) | ip[7], + (((unsigned short)ip[8]) << 8) | ip[9], + (((unsigned short)ip[10]) << 8) | ip[11], + (((unsigned short)ip[12]) << 8) | ip[13], + (((unsigned short)ip[14]) << 8) | ip[15], + }, + // TODO wasi-sockets: do these need to be endian-reversed? + .flow_info = ipv6->sin6_flowinfo, + .scope_id = ipv6->sin6_scope_id, + } } + }; + return true; + } + default: /* unreachable */ + abort(); + } +} + +bool __wasi_sockets_utils__output_addr_validate( + network_ip_address_family_t expected_family, struct sockaddr *addr, + socklen_t *addrlen, output_sockaddr_t *result) +{ + // The address parameters must be either both null or both _not_ null. + + if (addr == NULL && addrlen == NULL) { + *result = (output_sockaddr_t){ .tag = OUTPUT_SOCKADDR_NULL, + .null = {} }; + return true; + + } else if (addr != NULL && addrlen != NULL) { + if (expected_family == NETWORK_IP_ADDRESS_FAMILY_IPV4) { + if (*addrlen < sizeof(struct sockaddr_in)) { + return false; + } + + *result = + (output_sockaddr_t){ .tag = OUTPUT_SOCKADDR_V4, + .v4 = { + .addr = (struct sockaddr_in + *) + addr, + .addrlen = addrlen, + } }; + return true; + + } else if (expected_family == NETWORK_IP_ADDRESS_FAMILY_IPV6) { + if (*addrlen < sizeof(struct sockaddr_in6)) { + return false; + } + + *result = + (output_sockaddr_t){ .tag = OUTPUT_SOCKADDR_V6, + .v6 = { + .addr = (struct sockaddr_in6 + *) + addr, + .addrlen = addrlen, + } }; + return true; + + } else { + abort(); + } + + } else { + return false; + } +} + +void __wasi_sockets_utils__output_addr_write( + const network_ip_socket_address_t input, output_sockaddr_t *output) +{ + switch (input.tag) { + case NETWORK_IP_SOCKET_ADDRESS_IPV4: { + if (output->tag != OUTPUT_SOCKADDR_V4) { + abort(); + } + + network_ipv4_socket_address_t input_v4 = input.val.ipv4; + network_ipv4_address_t ip = input_v4.address; + + *output->v4.addrlen = sizeof(struct sockaddr_in); + *output->v4.addr = (struct sockaddr_in){ + .sin_family = AF_INET, + .sin_port = htons(input_v4.port), + .sin_addr = { .s_addr = ip.f0 | (ip.f1 << 8) | + (ip.f2 << 16) | (ip.f3 << 24) }, + }; + return; + } + case NETWORK_IP_SOCKET_ADDRESS_IPV6: { + if (output->tag != OUTPUT_SOCKADDR_V6) { + abort(); + } + + network_ipv6_socket_address_t input_v6 = input.val.ipv6; + network_ipv6_address_t ip = input_v6.address; + + *output->v6.addrlen = sizeof(struct sockaddr_in6); + *output->v6.addr = (struct sockaddr_in6) { + .sin6_family = AF_INET6, + .sin6_port = htons(input_v6.port), + .sin6_addr = { .s6_addr = { + ip.f0 >> 8, ip.f0 & 0xFF, + ip.f1 >> 8, ip.f1 & 0xFF, + ip.f2 >> 8, ip.f2 & 0xFF, + ip.f3 >> 8, ip.f3 & 0xFF, + ip.f4 >> 8, ip.f4 & 0xFF, + ip.f5 >> 8, ip.f5 & 0xFF, + ip.f6 >> 8, ip.f6 & 0xFF, + ip.f7 >> 8, ip.f7 & 0xFF, + } }, + // TODO wasi-sockets: do these need to be endian-reversed? + .sin6_flowinfo = input_v6.flow_info, + .sin6_scope_id = input_v6.scope_id, + }; + return; + } + default: /* unreachable */ + abort(); + } +} + +int __wasi_sockets_utils__posix_family(network_ip_address_family_t wasi_family) +{ + switch (wasi_family) { + case NETWORK_IP_ADDRESS_FAMILY_IPV4: + return AF_INET; + case NETWORK_IP_ADDRESS_FAMILY_IPV6: + return AF_INET6; + default: /* unreachable */ + abort(); + } +} + +network_ip_socket_address_t +__wasi_sockets_utils__any_addr(network_ip_address_family_t family) +{ + switch (family) { + case NETWORK_IP_ADDRESS_FAMILY_IPV4: + return (network_ip_socket_address_t){ .tag = NETWORK_IP_SOCKET_ADDRESS_IPV4, + .val = { + .ipv4 = { + .port = 0, + .address = { 0, + 0, + 0, + 0 }, + } } }; + case NETWORK_IP_ADDRESS_FAMILY_IPV6: + return (network_ip_socket_address_t){ .tag = NETWORK_IP_SOCKET_ADDRESS_IPV6, + .val = { + .ipv6 = { + .port = 0, + .address = { 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 }, + .flow_info = + 0, + .scope_id = + 0, + } } }; + default: /* unreachable */ + abort(); + } +} + +int __wasi_sockets_utils__tcp_bind(tcp_socket_t *socket, + network_ip_socket_address_t *address) +{ + tcp_socket_state_unbound_t unbound; + if (socket->state.tag == TCP_SOCKET_STATE_UNBOUND) { + unbound = socket->state.unbound; + } else { + errno = EINVAL; + return -1; + } + + network_error_code_t error; + network_borrow_network_t network_borrow = + __wasi_sockets_utils__borrow_network(); + tcp_borrow_tcp_socket_t socket_borrow = + tcp_borrow_tcp_socket(socket->socket); + + if (!tcp_method_tcp_socket_start_bind(socket_borrow, network_borrow, + address, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + // Bind has successfully started. Attempt to finish it: + while (!tcp_method_tcp_socket_finish_bind(socket_borrow, &error)) { + if (error == NETWORK_ERROR_CODE_WOULD_BLOCK) { + poll_borrow_pollable_t pollable_borrow = + poll_borrow_pollable(socket->socket_pollable); + poll_method_pollable_block(pollable_borrow); + } else { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + } + + // Bind successful. + + socket->state = + (tcp_socket_state_t){ .tag = TCP_SOCKET_STATE_BOUND, + .bound = { /* No additional state */ } }; + return 0; +} + +int __wasi_sockets_utils__udp_bind(udp_socket_t *socket, + network_ip_socket_address_t *address) +{ + udp_socket_state_unbound_t unbound; + if (socket->state.tag == UDP_SOCKET_STATE_UNBOUND) { + unbound = socket->state.unbound; + } else { + errno = EINVAL; + return -1; + } + + network_error_code_t error; + network_borrow_network_t network_borrow = + __wasi_sockets_utils__borrow_network(); + udp_borrow_udp_socket_t socket_borrow = + udp_borrow_udp_socket(socket->socket); + + if (!udp_method_udp_socket_start_bind(socket_borrow, network_borrow, + address, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + // Bind has successfully started. Attempt to finish it: + while (!udp_method_udp_socket_finish_bind(socket_borrow, &error)) { + if (error == NETWORK_ERROR_CODE_WOULD_BLOCK) { + poll_borrow_pollable_t pollable_borrow = + poll_borrow_pollable(socket->socket_pollable); + poll_method_pollable_block(pollable_borrow); + } else { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + } + + // Bind successful. + + socket->state = + (udp_socket_state_t){ .tag = UDP_SOCKET_STATE_BOUND_NOSTREAMS, + .bound_nostreams = {} }; + return 0; +} + +bool __wasi_sockets_utils__create_streams( + udp_borrow_udp_socket_t socket_borrow, + network_ip_socket_address_t *remote_address, + udp_socket_streams_t *result, network_error_code_t *error) +{ + udp_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_t + io; + if (!udp_method_udp_socket_stream(socket_borrow, remote_address, &io, + error)) { + return false; + } + + udp_own_incoming_datagram_stream_t incoming = io.f0; + udp_borrow_incoming_datagram_stream_t incoming_borrow = + udp_borrow_incoming_datagram_stream(incoming); + poll_own_pollable_t incoming_pollable = + udp_method_incoming_datagram_stream_subscribe(incoming_borrow); + + udp_own_outgoing_datagram_stream_t outgoing = io.f1; + udp_borrow_outgoing_datagram_stream_t outgoing_borrow = + udp_borrow_outgoing_datagram_stream(outgoing); + poll_own_pollable_t outgoing_pollable = + udp_method_outgoing_datagram_stream_subscribe(outgoing_borrow); + + *result = (udp_socket_streams_t){ + .incoming = incoming, + .incoming_pollable = incoming_pollable, + .outgoing = outgoing, + .outgoing_pollable = outgoing_pollable, + }; + return true; +} + +void __wasi_sockets_utils__drop_streams(udp_socket_streams_t streams) +{ + poll_pollable_drop_own(streams.incoming_pollable); + poll_pollable_drop_own(streams.outgoing_pollable); + udp_incoming_datagram_stream_drop_own(streams.incoming); + udp_outgoing_datagram_stream_drop_own(streams.outgoing); +} + +bool __wasi_sockets_utils__stream( + udp_socket_t *socket, + network_ip_socket_address_t + *remote_address, // May be null to "disconnect" + udp_socket_streams_t *result, network_error_code_t *error) +{ + // Assert that: + // - We're already bound. This is required by WASI. + // - We have no active streams. From WASI: + // > Implementations may trap if the streams returned by a previous + // > invocation haven't been dropped yet before calling `stream` again. + if (socket->state.tag != UDP_SOCKET_STATE_BOUND_NOSTREAMS) { + abort(); + } + + udp_borrow_udp_socket_t socket_borrow = + udp_borrow_udp_socket(socket->socket); + + if (!__wasi_sockets_utils__create_streams(socket_borrow, remote_address, + result, error)) { + return false; + } + + if (remote_address != NULL) { + socket->state = + (udp_socket_state_t){ .tag = UDP_SOCKET_STATE_CONNECTED, + .connected = { + .streams = *result, + } }; + } else { + socket->state = + (udp_socket_state_t){ .tag = UDP_SOCKET_STATE_BOUND_STREAMING, + .bound_streaming = { + .streams = *result, + } }; + } + + return true; +} diff --git a/libc-bottom-half/sources/sockopt.c b/libc-bottom-half/sources/sockopt.c new file mode 100644 index 0000000..863d115 --- /dev/null +++ b/libc-bottom-half/sources/sockopt.c @@ -0,0 +1,683 @@ +#include <sys/socket.h> +#include <netinet/in.h> +#include <netinet/tcp.h> + +#include <errno.h> +#include <limits.h> +#include <string.h> + +#include <wasi/api.h> +#include <wasi/descriptor_table.h> +#include <wasi/sockets_utils.h> + +const uint64_t NS_PER_S = 1000000000; + +int tcp_getsockopt(tcp_socket_t *socket, int level, int optname, + void *restrict optval, socklen_t *restrict optlen) +{ + int value = 0; + + network_error_code_t error; + tcp_borrow_tcp_socket_t socket_borrow = + tcp_borrow_tcp_socket(socket->socket); + + switch (level) { + case SOL_SOCKET: + switch (optname) { + case SO_TYPE: { + value = SOCK_STREAM; + break; + } + case SO_PROTOCOL: { + value = IPPROTO_TCP; + break; + } + case SO_DOMAIN: { + value = __wasi_sockets_utils__posix_family( + socket->family); + break; + } + case SO_ERROR: { + if (socket->state.tag == + TCP_SOCKET_STATE_CONNECT_FAILED) { + value = __wasi_sockets_utils__map_error( + socket->state.connect_failed.error_code); + socket->state.connect_failed.error_code = 0; + } else { + value = 0; + } + break; + } + case SO_ACCEPTCONN: { + bool is_listening = socket->state.tag == + TCP_SOCKET_STATE_LISTENING; + if (is_listening != + tcp_method_tcp_socket_is_listening( + socket_borrow)) { // Sanity check. + abort(); + } + value = is_listening; + break; + } + case SO_KEEPALIVE: { + bool result; + if (!tcp_method_tcp_socket_keep_alive_enabled( + socket_borrow, &result, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + value = result; + break; + } + case SO_RCVBUF: { + uint64_t result; + if (!tcp_method_tcp_socket_receive_buffer_size( + socket_borrow, &result, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + if (result > INT_MAX) { + abort(); + } + + value = result; + break; + } + case SO_SNDBUF: { + uint64_t result; + if (!tcp_method_tcp_socket_send_buffer_size( + socket_borrow, &result, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + if (result > INT_MAX) { + abort(); + } + + value = result; + break; + } + case SO_REUSEADDR: { + value = socket->fake_reuseaddr; + break; + } + case SO_RCVTIMEO: // TODO wasi-sockets: emulate in wasi-libc itself + case SO_SNDTIMEO: // TODO wasi-sockets: emulate in wasi-libc itself + default: + errno = ENOPROTOOPT; + return -1; + } + break; + + case SOL_IP: + switch (optname) { + case IP_TTL: { + if (socket->family != NETWORK_IP_ADDRESS_FAMILY_IPV4) { + errno = EAFNOSUPPORT; + return -1; + } + + uint8_t result; + if (!tcp_method_tcp_socket_hop_limit(socket_borrow, + &result, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + value = result; + break; + } + default: + errno = ENOPROTOOPT; + return -1; + } + break; + + case SOL_IPV6: + switch (optname) { + case IPV6_UNICAST_HOPS: { + if (socket->family != NETWORK_IP_ADDRESS_FAMILY_IPV6) { + errno = EAFNOSUPPORT; + return -1; + } + + uint8_t result; + if (!tcp_method_tcp_socket_hop_limit(socket_borrow, + &result, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + value = result; + break; + } + default: + errno = ENOPROTOOPT; + return -1; + } + break; + + case SOL_TCP: + switch (optname) { + case TCP_NODELAY: { + value = socket->fake_nodelay; + break; + } + case TCP_KEEPIDLE: { + tcp_duration_t result_ns; + if (!tcp_method_tcp_socket_keep_alive_idle_time( + socket_borrow, &result_ns, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + uint64_t result_s = result_ns / NS_PER_S; + if (result_s == 0) { + result_s = + 1; // Value was rounded down to zero. Round it up instead, because 0 is an invalid value for this socket option. + } + + if (result_s > INT_MAX) { + abort(); + } + + value = result_s; + break; + } + case TCP_KEEPINTVL: { + tcp_duration_t result_ns; + if (!tcp_method_tcp_socket_keep_alive_interval( + socket_borrow, &result_ns, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + uint64_t result_s = result_ns / NS_PER_S; + if (result_s == 0) { + result_s = + 1; // Value was rounded down to zero. Round it up instead, because 0 is an invalid value for this socket option. + } + + if (result_s > INT_MAX) { + abort(); + } + + value = result_s; + break; + } + case TCP_KEEPCNT: { + uint32_t result; + if (!tcp_method_tcp_socket_keep_alive_count( + socket_borrow, &result, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + if (result > INT_MAX) { + abort(); + } + + value = result; + break; + break; + } + default: + errno = ENOPROTOOPT; + return -1; + } + break; + + default: + errno = ENOPROTOOPT; + return -1; + } + + // Copy out integer value. + memcpy(optval, &value, *optlen < sizeof(int) ? *optlen : sizeof(int)); + *optlen = sizeof(int); + return 0; +} + +int tcp_setsockopt(tcp_socket_t *socket, int level, int optname, + const void *optval, socklen_t optlen) +{ + int intval = *(int *)optval; + + network_error_code_t error; + tcp_borrow_tcp_socket_t socket_borrow = + tcp_borrow_tcp_socket(socket->socket); + + switch (level) { + case SOL_SOCKET: + switch (optname) { + case SO_KEEPALIVE: { + if (!tcp_method_tcp_socket_set_keep_alive_enabled( + socket_borrow, intval != 0, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + return 0; + } + case SO_RCVBUF: { + if (!tcp_method_tcp_socket_set_receive_buffer_size( + socket_borrow, intval, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + return 0; + } + case SO_SNDBUF: { + if (!tcp_method_tcp_socket_set_send_buffer_size( + socket_borrow, intval, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + return 0; + } + case SO_REUSEADDR: { + // As of this writing, WASI has no support for changing SO_REUSEADDR + // -- it's enabled by default and cannot be disabled. To keep + // applications happy, we pretend to support enabling and disabling + // it. + socket->fake_reuseaddr = (intval != 0); + return 0; + } + case SO_RCVTIMEO: // TODO wasi-sockets: emulate in wasi-libc itself + case SO_SNDTIMEO: // TODO wasi-sockets: emulate in wasi-libc itself + default: + errno = ENOPROTOOPT; + return -1; + } + break; + + case SOL_IP: + switch (optname) { + case IP_TTL: { + if (socket->family != NETWORK_IP_ADDRESS_FAMILY_IPV4) { + errno = EAFNOSUPPORT; + return -1; + } + + if (intval < 0 || intval > UINT8_MAX) { + errno = EINVAL; + return -1; + } + + if (!tcp_method_tcp_socket_set_hop_limit( + socket_borrow, intval, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + return 0; + } + default: + errno = ENOPROTOOPT; + return -1; + } + break; + + case SOL_IPV6: + switch (optname) { + case IPV6_UNICAST_HOPS: { + if (socket->family != NETWORK_IP_ADDRESS_FAMILY_IPV6) { + errno = EAFNOSUPPORT; + return -1; + } + + if (intval < 0 || intval > UINT8_MAX) { + errno = EINVAL; + return -1; + } + + if (!tcp_method_tcp_socket_set_hop_limit( + socket_borrow, intval, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + return 0; + } + default: + errno = ENOPROTOOPT; + return -1; + } + break; + + case SOL_TCP: + switch (optname) { + case TCP_NODELAY: { + // At the time of writing, WASI has no support for TCP_NODELAY. + // Yet, many applications expect this option to be implemented. + // To ensure those applications can run on WASI at all, we fake + // support for it by recording the value, but not doing anything + // with it. + // If/when WASI adds true support, we can remove this workaround + // and implement it properly. From the application's perspective + // the "worst" thing that can then happen is that it automagically + // becomes faster. + socket->fake_nodelay = (intval != 0); + return 0; + } + case TCP_KEEPIDLE: { + tcp_duration_t duration = intval * NS_PER_S; + if (!tcp_method_tcp_socket_set_keep_alive_idle_time( + socket_borrow, duration, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + return 0; + } + case TCP_KEEPINTVL: { + tcp_duration_t duration = intval * NS_PER_S; + if (!tcp_method_tcp_socket_set_keep_alive_interval( + socket_borrow, duration, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + return 0; + } + case TCP_KEEPCNT: { + if (!tcp_method_tcp_socket_set_keep_alive_count( + socket_borrow, intval, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + return 0; + } + default: + errno = ENOPROTOOPT; + return -1; + } + break; + + default: + errno = ENOPROTOOPT; + return -1; + } +} + +int udp_getsockopt(udp_socket_t *socket, int level, int optname, + void *restrict optval, socklen_t *restrict optlen) +{ + int value; + + network_error_code_t error; + udp_borrow_udp_socket_t socket_borrow = + udp_borrow_udp_socket(socket->socket); + + switch (level) { + case SOL_SOCKET: + switch (optname) { + case SO_TYPE: { + value = SOCK_DGRAM; + break; + } + case SO_PROTOCOL: { + value = IPPROTO_UDP; + break; + } + case SO_DOMAIN: { + value = __wasi_sockets_utils__posix_family( + socket->family); + break; + } + case SO_RCVBUF: { + uint64_t result; + if (!udp_method_udp_socket_receive_buffer_size( + socket_borrow, &result, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + if (result > INT_MAX) { + abort(); + } + + value = result; + break; + } + case SO_SNDBUF: { + uint64_t result; + if (!udp_method_udp_socket_send_buffer_size( + socket_borrow, &result, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + if (result > INT_MAX) { + abort(); + } + + value = result; + break; + } + case SO_RCVTIMEO: // TODO wasi-sockets: emulate in wasi-libc itself + case SO_SNDTIMEO: // TODO wasi-sockets: emulate in wasi-libc itself + default: + errno = ENOPROTOOPT; + return -1; + } + break; + + case SOL_IP: + switch (optname) { + case IP_TTL: { + if (socket->family != NETWORK_IP_ADDRESS_FAMILY_IPV4) { + errno = EAFNOSUPPORT; + return -1; + } + + uint8_t result; + if (!udp_method_udp_socket_unicast_hop_limit( + socket_borrow, &result, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + value = result; + break; + } + default: + errno = ENOPROTOOPT; + return -1; + } + break; + + case SOL_IPV6: + switch (optname) { + case IPV6_UNICAST_HOPS: { + if (socket->family != NETWORK_IP_ADDRESS_FAMILY_IPV6) { + errno = EAFNOSUPPORT; + return -1; + } + + uint8_t result; + if (!udp_method_udp_socket_unicast_hop_limit( + socket_borrow, &result, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + value = result; + break; + } + default: + errno = ENOPROTOOPT; + return -1; + } + break; + + default: + errno = ENOPROTOOPT; + return -1; + } + + // Copy out integer value. + memcpy(optval, &value, *optlen < sizeof(int) ? *optlen : sizeof(int)); + *optlen = sizeof(int); + return 0; +} + +int udp_setsockopt(udp_socket_t *socket, int level, int optname, + const void *optval, socklen_t optlen) +{ + int intval = *(int *)optval; + + network_error_code_t error; + udp_borrow_udp_socket_t socket_borrow = + udp_borrow_udp_socket(socket->socket); + + switch (level) { + case SOL_SOCKET: + switch (optname) { + case SO_RCVBUF: { + if (!udp_method_udp_socket_set_receive_buffer_size( + socket_borrow, intval, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + return 0; + } + case SO_SNDBUF: { + if (!udp_method_udp_socket_set_send_buffer_size( + socket_borrow, intval, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + return 0; + } + case SO_RCVTIMEO: // TODO wasi-sockets: emulate in wasi-libc itself + case SO_SNDTIMEO: // TODO wasi-sockets: emulate in wasi-libc itself + default: + errno = ENOPROTOOPT; + return -1; + } + break; + + case SOL_IP: + switch (optname) { + case IP_TTL: { + if (socket->family != NETWORK_IP_ADDRESS_FAMILY_IPV4) { + errno = EAFNOSUPPORT; + return -1; + } + + if (intval < 0 || intval > UINT8_MAX) { + errno = EINVAL; + return -1; + } + + if (!udp_method_udp_socket_set_unicast_hop_limit( + socket_borrow, intval, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + return 0; + } + default: + errno = ENOPROTOOPT; + return -1; + } + break; + + case SOL_IPV6: + switch (optname) { + case IPV6_UNICAST_HOPS: { + if (socket->family != NETWORK_IP_ADDRESS_FAMILY_IPV6) { + errno = EAFNOSUPPORT; + return -1; + } + + if (intval < 0 || intval > UINT8_MAX) { + errno = EINVAL; + return -1; + } + + if (!udp_method_udp_socket_set_unicast_hop_limit( + socket_borrow, intval, &error)) { + errno = __wasi_sockets_utils__map_error(error); + return -1; + } + + return 0; + } + default: + errno = ENOPROTOOPT; + return -1; + } + break; + + default: + errno = ENOPROTOOPT; + return -1; + } +} + +int getsockopt(int sockfd, int level, int optname, void *restrict optval, + socklen_t *restrict optlen) +{ + descriptor_table_entry_t *entry; + if (!descriptor_table_get_ref(sockfd, &entry)) { + errno = EBADF; + return -1; + } + + if (optval == NULL || optlen == NULL || *optlen < sizeof(int)) { + // FYI, the protocol-specific implementations implicitly depend on these checks. + errno = EINVAL; + return -1; + } + + switch (entry->tag) { + case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET: + return tcp_getsockopt(&entry->tcp_socket, level, optname, + optval, optlen); + case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET: + return udp_getsockopt(&entry->udp_socket, level, optname, + optval, optlen); + default: + errno = ENOPROTOOPT; + return -1; + } +} + +int setsockopt(int sockfd, int level, int optname, const void *optval, + socklen_t optlen) +{ + descriptor_table_entry_t *entry; + if (!descriptor_table_get_ref(sockfd, &entry)) { + errno = EBADF; + return -1; + } + + if (optval == NULL || optlen < sizeof(int)) { + // FYI, the protocol-specific implementations implicitly depend on these checks. + errno = EINVAL; + return -1; + } + + switch (entry->tag) { + case DESCRIPTOR_TABLE_ENTRY_TCP_SOCKET: + return tcp_setsockopt(&entry->tcp_socket, level, optname, + optval, optlen); + case DESCRIPTOR_TABLE_ENTRY_UDP_SOCKET: + return udp_setsockopt(&entry->udp_socket, level, optname, + optval, optlen); + default: + errno = ENOPROTOOPT; + return -1; + } +} diff --git a/libc-bottom-half/sources/wasip2.c b/libc-bottom-half/sources/wasip2.c new file mode 100644 index 0000000..c55c3b0 --- /dev/null +++ b/libc-bottom-half/sources/wasip2.c @@ -0,0 +1,4326 @@ +// Generated by `wit-bindgen` 0.17.0. DO NOT EDIT! +#include "wasi/wasip2.h" + + +__attribute__((__import_module__("wasi:cli/environment@0.2.0"), __import_name__("get-environment"))) +extern void __wasm_import_environment_get_environment(int32_t); + +__attribute__((__import_module__("wasi:cli/environment@0.2.0"), __import_name__("get-arguments"))) +extern void __wasm_import_environment_get_arguments(int32_t); + +__attribute__((__import_module__("wasi:cli/environment@0.2.0"), __import_name__("initial-cwd"))) +extern void __wasm_import_environment_initial_cwd(int32_t); + +__attribute__((__import_module__("wasi:cli/exit@0.2.0"), __import_name__("exit"))) +extern void __wasm_import_exit_exit(int32_t); + +__attribute__((__import_module__("wasi:io/error@0.2.0"), __import_name__("[method]error.to-debug-string"))) +extern void __wasm_import_io_error_method_error_to_debug_string(int32_t, int32_t); + +__attribute__((__import_module__("wasi:io/poll@0.2.0"), __import_name__("[method]pollable.ready"))) +extern int32_t __wasm_import_poll_method_pollable_ready(int32_t); + +__attribute__((__import_module__("wasi:io/poll@0.2.0"), __import_name__("[method]pollable.block"))) +extern void __wasm_import_poll_method_pollable_block(int32_t); + +__attribute__((__import_module__("wasi:io/poll@0.2.0"), __import_name__("poll"))) +extern void __wasm_import_poll_poll(int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]input-stream.read"))) +extern void __wasm_import_streams_method_input_stream_read(int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]input-stream.blocking-read"))) +extern void __wasm_import_streams_method_input_stream_blocking_read(int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]input-stream.skip"))) +extern void __wasm_import_streams_method_input_stream_skip(int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]input-stream.blocking-skip"))) +extern void __wasm_import_streams_method_input_stream_blocking_skip(int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]input-stream.subscribe"))) +extern int32_t __wasm_import_streams_method_input_stream_subscribe(int32_t); + +__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.check-write"))) +extern void __wasm_import_streams_method_output_stream_check_write(int32_t, int32_t); + +__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.write"))) +extern void __wasm_import_streams_method_output_stream_write(int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.blocking-write-and-flush"))) +extern void __wasm_import_streams_method_output_stream_blocking_write_and_flush(int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.flush"))) +extern void __wasm_import_streams_method_output_stream_flush(int32_t, int32_t); + +__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.blocking-flush"))) +extern void __wasm_import_streams_method_output_stream_blocking_flush(int32_t, int32_t); + +__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.subscribe"))) +extern int32_t __wasm_import_streams_method_output_stream_subscribe(int32_t); + +__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.write-zeroes"))) +extern void __wasm_import_streams_method_output_stream_write_zeroes(int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.blocking-write-zeroes-and-flush"))) +extern void __wasm_import_streams_method_output_stream_blocking_write_zeroes_and_flush(int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.splice"))) +extern void __wasm_import_streams_method_output_stream_splice(int32_t, int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[method]output-stream.blocking-splice"))) +extern void __wasm_import_streams_method_output_stream_blocking_splice(int32_t, int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:cli/stdin@0.2.0"), __import_name__("get-stdin"))) +extern int32_t __wasm_import_stdin_get_stdin(void); + +__attribute__((__import_module__("wasi:cli/stdout@0.2.0"), __import_name__("get-stdout"))) +extern int32_t __wasm_import_stdout_get_stdout(void); + +__attribute__((__import_module__("wasi:cli/stderr@0.2.0"), __import_name__("get-stderr"))) +extern int32_t __wasm_import_stderr_get_stderr(void); + +__attribute__((__import_module__("wasi:cli/terminal-stdin@0.2.0"), __import_name__("get-terminal-stdin"))) +extern void __wasm_import_terminal_stdin_get_terminal_stdin(int32_t); + +__attribute__((__import_module__("wasi:cli/terminal-stdout@0.2.0"), __import_name__("get-terminal-stdout"))) +extern void __wasm_import_terminal_stdout_get_terminal_stdout(int32_t); + +__attribute__((__import_module__("wasi:cli/terminal-stderr@0.2.0"), __import_name__("get-terminal-stderr"))) +extern void __wasm_import_terminal_stderr_get_terminal_stderr(int32_t); + +__attribute__((__import_module__("wasi:clocks/monotonic-clock@0.2.0"), __import_name__("now"))) +extern int64_t __wasm_import_monotonic_clock_now(void); + +__attribute__((__import_module__("wasi:clocks/monotonic-clock@0.2.0"), __import_name__("resolution"))) +extern int64_t __wasm_import_monotonic_clock_resolution(void); + +__attribute__((__import_module__("wasi:clocks/monotonic-clock@0.2.0"), __import_name__("subscribe-instant"))) +extern int32_t __wasm_import_monotonic_clock_subscribe_instant(int64_t); + +__attribute__((__import_module__("wasi:clocks/monotonic-clock@0.2.0"), __import_name__("subscribe-duration"))) +extern int32_t __wasm_import_monotonic_clock_subscribe_duration(int64_t); + +__attribute__((__import_module__("wasi:clocks/wall-clock@0.2.0"), __import_name__("now"))) +extern void __wasm_import_wall_clock_now(int32_t); + +__attribute__((__import_module__("wasi:clocks/wall-clock@0.2.0"), __import_name__("resolution"))) +extern void __wasm_import_wall_clock_resolution(int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.read-via-stream"))) +extern void __wasm_import_filesystem_method_descriptor_read_via_stream(int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.write-via-stream"))) +extern void __wasm_import_filesystem_method_descriptor_write_via_stream(int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.append-via-stream"))) +extern void __wasm_import_filesystem_method_descriptor_append_via_stream(int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.advise"))) +extern void __wasm_import_filesystem_method_descriptor_advise(int32_t, int64_t, int64_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.sync-data"))) +extern void __wasm_import_filesystem_method_descriptor_sync_data(int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.get-flags"))) +extern void __wasm_import_filesystem_method_descriptor_get_flags(int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.get-type"))) +extern void __wasm_import_filesystem_method_descriptor_get_type(int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.set-size"))) +extern void __wasm_import_filesystem_method_descriptor_set_size(int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.set-times"))) +extern void __wasm_import_filesystem_method_descriptor_set_times(int32_t, int32_t, int64_t, int32_t, int32_t, int64_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.read"))) +extern void __wasm_import_filesystem_method_descriptor_read(int32_t, int64_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.write"))) +extern void __wasm_import_filesystem_method_descriptor_write(int32_t, int32_t, int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.read-directory"))) +extern void __wasm_import_filesystem_method_descriptor_read_directory(int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.sync"))) +extern void __wasm_import_filesystem_method_descriptor_sync(int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.create-directory-at"))) +extern void __wasm_import_filesystem_method_descriptor_create_directory_at(int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.stat"))) +extern void __wasm_import_filesystem_method_descriptor_stat(int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.stat-at"))) +extern void __wasm_import_filesystem_method_descriptor_stat_at(int32_t, int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.set-times-at"))) +extern void __wasm_import_filesystem_method_descriptor_set_times_at(int32_t, int32_t, int32_t, int32_t, int32_t, int64_t, int32_t, int32_t, int64_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.link-at"))) +extern void __wasm_import_filesystem_method_descriptor_link_at(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.open-at"))) +extern void __wasm_import_filesystem_method_descriptor_open_at(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.readlink-at"))) +extern void __wasm_import_filesystem_method_descriptor_readlink_at(int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.remove-directory-at"))) +extern void __wasm_import_filesystem_method_descriptor_remove_directory_at(int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.rename-at"))) +extern void __wasm_import_filesystem_method_descriptor_rename_at(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.symlink-at"))) +extern void __wasm_import_filesystem_method_descriptor_symlink_at(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.unlink-file-at"))) +extern void __wasm_import_filesystem_method_descriptor_unlink_file_at(int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.is-same-object"))) +extern int32_t __wasm_import_filesystem_method_descriptor_is_same_object(int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.metadata-hash"))) +extern void __wasm_import_filesystem_method_descriptor_metadata_hash(int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]descriptor.metadata-hash-at"))) +extern void __wasm_import_filesystem_method_descriptor_metadata_hash_at(int32_t, int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[method]directory-entry-stream.read-directory-entry"))) +extern void __wasm_import_filesystem_method_directory_entry_stream_read_directory_entry(int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("filesystem-error-code"))) +extern void __wasm_import_filesystem_filesystem_error_code(int32_t, int32_t); + +__attribute__((__import_module__("wasi:filesystem/preopens@0.2.0"), __import_name__("get-directories"))) +extern void __wasm_import_filesystem_preopens_get_directories(int32_t); + +__attribute__((__import_module__("wasi:sockets/instance-network@0.2.0"), __import_name__("instance-network"))) +extern int32_t __wasm_import_instance_network_instance_network(void); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.start-bind"))) +extern void __wasm_import_udp_method_udp_socket_start_bind(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.finish-bind"))) +extern void __wasm_import_udp_method_udp_socket_finish_bind(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.stream"))) +extern void __wasm_import_udp_method_udp_socket_stream(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.local-address"))) +extern void __wasm_import_udp_method_udp_socket_local_address(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.remote-address"))) +extern void __wasm_import_udp_method_udp_socket_remote_address(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.address-family"))) +extern int32_t __wasm_import_udp_method_udp_socket_address_family(int32_t); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.unicast-hop-limit"))) +extern void __wasm_import_udp_method_udp_socket_unicast_hop_limit(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.set-unicast-hop-limit"))) +extern void __wasm_import_udp_method_udp_socket_set_unicast_hop_limit(int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.receive-buffer-size"))) +extern void __wasm_import_udp_method_udp_socket_receive_buffer_size(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.set-receive-buffer-size"))) +extern void __wasm_import_udp_method_udp_socket_set_receive_buffer_size(int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.send-buffer-size"))) +extern void __wasm_import_udp_method_udp_socket_send_buffer_size(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.set-send-buffer-size"))) +extern void __wasm_import_udp_method_udp_socket_set_send_buffer_size(int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]udp-socket.subscribe"))) +extern int32_t __wasm_import_udp_method_udp_socket_subscribe(int32_t); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]incoming-datagram-stream.receive"))) +extern void __wasm_import_udp_method_incoming_datagram_stream_receive(int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]incoming-datagram-stream.subscribe"))) +extern int32_t __wasm_import_udp_method_incoming_datagram_stream_subscribe(int32_t); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]outgoing-datagram-stream.check-send"))) +extern void __wasm_import_udp_method_outgoing_datagram_stream_check_send(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]outgoing-datagram-stream.send"))) +extern void __wasm_import_udp_method_outgoing_datagram_stream_send(int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[method]outgoing-datagram-stream.subscribe"))) +extern int32_t __wasm_import_udp_method_outgoing_datagram_stream_subscribe(int32_t); + +__attribute__((__import_module__("wasi:sockets/udp-create-socket@0.2.0"), __import_name__("create-udp-socket"))) +extern void __wasm_import_udp_create_socket_create_udp_socket(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.start-bind"))) +extern void __wasm_import_tcp_method_tcp_socket_start_bind(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.finish-bind"))) +extern void __wasm_import_tcp_method_tcp_socket_finish_bind(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.start-connect"))) +extern void __wasm_import_tcp_method_tcp_socket_start_connect(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.finish-connect"))) +extern void __wasm_import_tcp_method_tcp_socket_finish_connect(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.start-listen"))) +extern void __wasm_import_tcp_method_tcp_socket_start_listen(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.finish-listen"))) +extern void __wasm_import_tcp_method_tcp_socket_finish_listen(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.accept"))) +extern void __wasm_import_tcp_method_tcp_socket_accept(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.local-address"))) +extern void __wasm_import_tcp_method_tcp_socket_local_address(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.remote-address"))) +extern void __wasm_import_tcp_method_tcp_socket_remote_address(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.is-listening"))) +extern int32_t __wasm_import_tcp_method_tcp_socket_is_listening(int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.address-family"))) +extern int32_t __wasm_import_tcp_method_tcp_socket_address_family(int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.set-listen-backlog-size"))) +extern void __wasm_import_tcp_method_tcp_socket_set_listen_backlog_size(int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.keep-alive-enabled"))) +extern void __wasm_import_tcp_method_tcp_socket_keep_alive_enabled(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.set-keep-alive-enabled"))) +extern void __wasm_import_tcp_method_tcp_socket_set_keep_alive_enabled(int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.keep-alive-idle-time"))) +extern void __wasm_import_tcp_method_tcp_socket_keep_alive_idle_time(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.set-keep-alive-idle-time"))) +extern void __wasm_import_tcp_method_tcp_socket_set_keep_alive_idle_time(int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.keep-alive-interval"))) +extern void __wasm_import_tcp_method_tcp_socket_keep_alive_interval(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.set-keep-alive-interval"))) +extern void __wasm_import_tcp_method_tcp_socket_set_keep_alive_interval(int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.keep-alive-count"))) +extern void __wasm_import_tcp_method_tcp_socket_keep_alive_count(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.set-keep-alive-count"))) +extern void __wasm_import_tcp_method_tcp_socket_set_keep_alive_count(int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.hop-limit"))) +extern void __wasm_import_tcp_method_tcp_socket_hop_limit(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.set-hop-limit"))) +extern void __wasm_import_tcp_method_tcp_socket_set_hop_limit(int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.receive-buffer-size"))) +extern void __wasm_import_tcp_method_tcp_socket_receive_buffer_size(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.set-receive-buffer-size"))) +extern void __wasm_import_tcp_method_tcp_socket_set_receive_buffer_size(int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.send-buffer-size"))) +extern void __wasm_import_tcp_method_tcp_socket_send_buffer_size(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.set-send-buffer-size"))) +extern void __wasm_import_tcp_method_tcp_socket_set_send_buffer_size(int32_t, int64_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.subscribe"))) +extern int32_t __wasm_import_tcp_method_tcp_socket_subscribe(int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[method]tcp-socket.shutdown"))) +extern void __wasm_import_tcp_method_tcp_socket_shutdown(int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/tcp-create-socket@0.2.0"), __import_name__("create-tcp-socket"))) +extern void __wasm_import_tcp_create_socket_create_tcp_socket(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/ip-name-lookup@0.2.0"), __import_name__("resolve-addresses"))) +extern void __wasm_import_ip_name_lookup_resolve_addresses(int32_t, int32_t, int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/ip-name-lookup@0.2.0"), __import_name__("[method]resolve-address-stream.resolve-next-address"))) +extern void __wasm_import_ip_name_lookup_method_resolve_address_stream_resolve_next_address(int32_t, int32_t); + +__attribute__((__import_module__("wasi:sockets/ip-name-lookup@0.2.0"), __import_name__("[method]resolve-address-stream.subscribe"))) +extern int32_t __wasm_import_ip_name_lookup_method_resolve_address_stream_subscribe(int32_t); + +__attribute__((__import_module__("wasi:random/random@0.2.0"), __import_name__("get-random-bytes"))) +extern void __wasm_import_random_get_random_bytes(int64_t, int32_t); + +__attribute__((__import_module__("wasi:random/random@0.2.0"), __import_name__("get-random-u64"))) +extern int64_t __wasm_import_random_get_random_u64(void); + +__attribute__((__import_module__("wasi:random/insecure@0.2.0"), __import_name__("get-insecure-random-bytes"))) +extern void __wasm_import_random_insecure_get_insecure_random_bytes(int64_t, int32_t); + +__attribute__((__import_module__("wasi:random/insecure@0.2.0"), __import_name__("get-insecure-random-u64"))) +extern int64_t __wasm_import_random_insecure_get_insecure_random_u64(void); + +__attribute__((__import_module__("wasi:random/insecure-seed@0.2.0"), __import_name__("insecure-seed"))) +extern void __wasm_import_random_insecure_seed_insecure_seed(int32_t); + +__attribute__((__weak__, __export_name__("cabi_realloc"))) +void *cabi_realloc(void *ptr, size_t old_size, size_t align, size_t new_size) { + (void) old_size; + if (new_size == 0) return (void*) align; + void *ret = realloc(ptr, new_size); + if (!ret) abort(); + return ret; +} + +// Helper Functions + +void wasip2_tuple2_string_string_free(wasip2_tuple2_string_string_t *ptr) { + wasip2_string_free(&ptr->f0); + wasip2_string_free(&ptr->f1); +} + +void wasip2_list_tuple2_string_string_free(wasip2_list_tuple2_string_string_t *ptr) { + for (size_t i = 0; i < ptr->len; i++) { + wasip2_tuple2_string_string_free(&ptr->ptr[i]); + } + if (ptr->len > 0) { + free(ptr->ptr); + } +} + +void wasip2_list_string_free(wasip2_list_string_t *ptr) { + for (size_t i = 0; i < ptr->len; i++) { + wasip2_string_free(&ptr->ptr[i]); + } + if (ptr->len > 0) { + free(ptr->ptr); + } +} + +void wasip2_option_string_free(wasip2_option_string_t *ptr) { + if (ptr->is_some) { + wasip2_string_free(&ptr->val); + } +} + +void exit_result_void_void_free(exit_result_void_void_t *ptr) { + if (!ptr->is_err) { + } +} + +__attribute__((__import_module__("wasi:io/error@0.2.0"), __import_name__("[resource-drop]error"))) +extern void __wasm_import_io_error_error_drop(int32_t handle); + +void io_error_error_drop_own(io_error_own_error_t handle) { + __wasm_import_io_error_error_drop(handle.__handle); +} + +void io_error_error_drop_borrow(io_error_borrow_error_t handle) { + __wasm_import_io_error_error_drop(handle.__handle); +} + +io_error_borrow_error_t io_error_borrow_error(io_error_own_error_t arg) { + return (io_error_borrow_error_t) { arg.__handle }; +} + +__attribute__((__import_module__("wasi:io/poll@0.2.0"), __import_name__("[resource-drop]pollable"))) +extern void __wasm_import_poll_pollable_drop(int32_t handle); + +void poll_pollable_drop_own(poll_own_pollable_t handle) { + __wasm_import_poll_pollable_drop(handle.__handle); +} + +void poll_pollable_drop_borrow(poll_borrow_pollable_t handle) { + __wasm_import_poll_pollable_drop(handle.__handle); +} + +poll_borrow_pollable_t poll_borrow_pollable(poll_own_pollable_t arg) { + return (poll_borrow_pollable_t) { arg.__handle }; +} + +void poll_list_borrow_pollable_free(poll_list_borrow_pollable_t *ptr) { + for (size_t i = 0; i < ptr->len; i++) { + } + if (ptr->len > 0) { + free(ptr->ptr); + } +} + +void wasip2_list_u32_free(wasip2_list_u32_t *ptr) { + for (size_t i = 0; i < ptr->len; i++) { + } + if (ptr->len > 0) { + free(ptr->ptr); + } +} + +void streams_stream_error_free(streams_stream_error_t *ptr) { + switch ((int32_t) ptr->tag) { + case 0: { + break; + } + } +} + +__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[resource-drop]input-stream"))) +extern void __wasm_import_streams_input_stream_drop(int32_t handle); + +void streams_input_stream_drop_own(streams_own_input_stream_t handle) { + __wasm_import_streams_input_stream_drop(handle.__handle); +} + +void streams_input_stream_drop_borrow(streams_borrow_input_stream_t handle) { + __wasm_import_streams_input_stream_drop(handle.__handle); +} + +streams_borrow_input_stream_t streams_borrow_input_stream(streams_own_input_stream_t arg) { + return (streams_borrow_input_stream_t) { arg.__handle }; +} + +__attribute__((__import_module__("wasi:io/streams@0.2.0"), __import_name__("[resource-drop]output-stream"))) +extern void __wasm_import_streams_output_stream_drop(int32_t handle); + +void streams_output_stream_drop_own(streams_own_output_stream_t handle) { + __wasm_import_streams_output_stream_drop(handle.__handle); +} + +void streams_output_stream_drop_borrow(streams_borrow_output_stream_t handle) { + __wasm_import_streams_output_stream_drop(handle.__handle); +} + +streams_borrow_output_stream_t streams_borrow_output_stream(streams_own_output_stream_t arg) { + return (streams_borrow_output_stream_t) { arg.__handle }; +} + +void wasip2_list_u8_free(wasip2_list_u8_t *ptr) { + for (size_t i = 0; i < ptr->len; i++) { + } + if (ptr->len > 0) { + free(ptr->ptr); + } +} + +void streams_result_list_u8_stream_error_free(streams_result_list_u8_stream_error_t *ptr) { + if (!ptr->is_err) { + wasip2_list_u8_free(&ptr->val.ok); + } else { + streams_stream_error_free(&ptr->val.err); + } +} + +void streams_result_u64_stream_error_free(streams_result_u64_stream_error_t *ptr) { + if (!ptr->is_err) { + } else { + streams_stream_error_free(&ptr->val.err); + } +} + +void streams_result_void_stream_error_free(streams_result_void_stream_error_t *ptr) { + if (!ptr->is_err) { + } else { + streams_stream_error_free(&ptr->val.err); + } +} + +__attribute__((__import_module__("wasi:cli/terminal-input@0.2.0"), __import_name__("[resource-drop]terminal-input"))) +extern void __wasm_import_terminal_input_terminal_input_drop(int32_t handle); + +void terminal_input_terminal_input_drop_own(terminal_input_own_terminal_input_t handle) { + __wasm_import_terminal_input_terminal_input_drop(handle.__handle); +} + +void terminal_input_terminal_input_drop_borrow(terminal_input_borrow_terminal_input_t handle) { + __wasm_import_terminal_input_terminal_input_drop(handle.__handle); +} + +terminal_input_borrow_terminal_input_t terminal_input_borrow_terminal_input(terminal_input_own_terminal_input_t arg) { + return (terminal_input_borrow_terminal_input_t) { arg.__handle }; +} + +__attribute__((__import_module__("wasi:cli/terminal-output@0.2.0"), __import_name__("[resource-drop]terminal-output"))) +extern void __wasm_import_terminal_output_terminal_output_drop(int32_t handle); + +void terminal_output_terminal_output_drop_own(terminal_output_own_terminal_output_t handle) { + __wasm_import_terminal_output_terminal_output_drop(handle.__handle); +} + +void terminal_output_terminal_output_drop_borrow(terminal_output_borrow_terminal_output_t handle) { + __wasm_import_terminal_output_terminal_output_drop(handle.__handle); +} + +terminal_output_borrow_terminal_output_t terminal_output_borrow_terminal_output(terminal_output_own_terminal_output_t arg) { + return (terminal_output_borrow_terminal_output_t) { arg.__handle }; +} + +void terminal_stdin_option_own_terminal_input_free(terminal_stdin_option_own_terminal_input_t *ptr) { + if (ptr->is_some) { + } +} + +void terminal_stdout_option_own_terminal_output_free(terminal_stdout_option_own_terminal_output_t *ptr) { + if (ptr->is_some) { + } +} + +void terminal_stderr_option_own_terminal_output_free(terminal_stderr_option_own_terminal_output_t *ptr) { + if (ptr->is_some) { + } +} + +void filesystem_option_datetime_free(filesystem_option_datetime_t *ptr) { + if (ptr->is_some) { + } +} + +void filesystem_descriptor_stat_free(filesystem_descriptor_stat_t *ptr) { + filesystem_option_datetime_free(&ptr->data_access_timestamp); + filesystem_option_datetime_free(&ptr->data_modification_timestamp); + filesystem_option_datetime_free(&ptr->status_change_timestamp); +} + +void filesystem_new_timestamp_free(filesystem_new_timestamp_t *ptr) { + switch ((int32_t) ptr->tag) { + case 2: { + break; + } + } +} + +void filesystem_directory_entry_free(filesystem_directory_entry_t *ptr) { + wasip2_string_free(&ptr->name); +} + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[resource-drop]descriptor"))) +extern void __wasm_import_filesystem_descriptor_drop(int32_t handle); + +void filesystem_descriptor_drop_own(filesystem_own_descriptor_t handle) { + __wasm_import_filesystem_descriptor_drop(handle.__handle); +} + +void filesystem_descriptor_drop_borrow(filesystem_borrow_descriptor_t handle) { + __wasm_import_filesystem_descriptor_drop(handle.__handle); +} + +filesystem_borrow_descriptor_t filesystem_borrow_descriptor(filesystem_own_descriptor_t arg) { + return (filesystem_borrow_descriptor_t) { arg.__handle }; +} + +__attribute__((__import_module__("wasi:filesystem/types@0.2.0"), __import_name__("[resource-drop]directory-entry-stream"))) +extern void __wasm_import_filesystem_directory_entry_stream_drop(int32_t handle); + +void filesystem_directory_entry_stream_drop_own(filesystem_own_directory_entry_stream_t handle) { + __wasm_import_filesystem_directory_entry_stream_drop(handle.__handle); +} + +void filesystem_directory_entry_stream_drop_borrow(filesystem_borrow_directory_entry_stream_t handle) { + __wasm_import_filesystem_directory_entry_stream_drop(handle.__handle); +} + +filesystem_borrow_directory_entry_stream_t filesystem_borrow_directory_entry_stream(filesystem_own_directory_entry_stream_t arg) { + return (filesystem_borrow_directory_entry_stream_t) { arg.__handle }; +} + +void filesystem_result_own_input_stream_error_code_free(filesystem_result_own_input_stream_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void filesystem_result_own_output_stream_error_code_free(filesystem_result_own_output_stream_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void filesystem_result_void_error_code_free(filesystem_result_void_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void filesystem_result_descriptor_flags_error_code_free(filesystem_result_descriptor_flags_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void filesystem_result_descriptor_type_error_code_free(filesystem_result_descriptor_type_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void filesystem_result_tuple2_list_u8_bool_error_code_free(filesystem_result_tuple2_list_u8_bool_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void filesystem_result_filesize_error_code_free(filesystem_result_filesize_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void filesystem_result_own_directory_entry_stream_error_code_free(filesystem_result_own_directory_entry_stream_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void filesystem_result_descriptor_stat_error_code_free(filesystem_result_descriptor_stat_error_code_t *ptr) { + if (!ptr->is_err) { + filesystem_descriptor_stat_free(&ptr->val.ok); + } else { + } +} + +void filesystem_result_own_descriptor_error_code_free(filesystem_result_own_descriptor_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void filesystem_result_string_error_code_free(filesystem_result_string_error_code_t *ptr) { + if (!ptr->is_err) { + wasip2_string_free(&ptr->val.ok); + } else { + } +} + +void filesystem_result_metadata_hash_value_error_code_free(filesystem_result_metadata_hash_value_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void filesystem_option_directory_entry_free(filesystem_option_directory_entry_t *ptr) { + if (ptr->is_some) { + filesystem_directory_entry_free(&ptr->val); + } +} + +void filesystem_result_option_directory_entry_error_code_free(filesystem_result_option_directory_entry_error_code_t *ptr) { + if (!ptr->is_err) { + filesystem_option_directory_entry_free(&ptr->val.ok); + } else { + } +} + +void filesystem_option_error_code_free(filesystem_option_error_code_t *ptr) { + if (ptr->is_some) { + } +} + +void filesystem_preopens_tuple2_own_descriptor_string_free(filesystem_preopens_tuple2_own_descriptor_string_t *ptr) { + wasip2_string_free(&ptr->f1); +} + +void filesystem_preopens_list_tuple2_own_descriptor_string_free(filesystem_preopens_list_tuple2_own_descriptor_string_t *ptr) { + for (size_t i = 0; i < ptr->len; i++) { + filesystem_preopens_tuple2_own_descriptor_string_free(&ptr->ptr[i]); + } + if (ptr->len > 0) { + free(ptr->ptr); + } +} + +__attribute__((__import_module__("wasi:sockets/network@0.2.0"), __import_name__("[resource-drop]network"))) +extern void __wasm_import_network_network_drop(int32_t handle); + +void network_network_drop_own(network_own_network_t handle) { + __wasm_import_network_network_drop(handle.__handle); +} + +void network_network_drop_borrow(network_borrow_network_t handle) { + __wasm_import_network_network_drop(handle.__handle); +} + +network_borrow_network_t network_borrow_network(network_own_network_t arg) { + return (network_borrow_network_t) { arg.__handle }; +} + +void network_ip_address_free(network_ip_address_t *ptr) { + switch ((int32_t) ptr->tag) { + case 0: { + break; + } + case 1: { + break; + } + } +} + +void network_ip_socket_address_free(network_ip_socket_address_t *ptr) { + switch ((int32_t) ptr->tag) { + case 0: { + break; + } + case 1: { + break; + } + } +} + +void udp_ip_socket_address_free(udp_ip_socket_address_t *ptr) { + network_ip_socket_address_free(ptr); +} + +void udp_incoming_datagram_free(udp_incoming_datagram_t *ptr) { + udp_ip_socket_address_free(&ptr->remote_address); +} + +void udp_option_ip_socket_address_free(udp_option_ip_socket_address_t *ptr) { + if (ptr->is_some) { + udp_ip_socket_address_free(&ptr->val); + } +} + +void udp_outgoing_datagram_free(udp_outgoing_datagram_t *ptr) { + udp_option_ip_socket_address_free(&ptr->remote_address); +} + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[resource-drop]udp-socket"))) +extern void __wasm_import_udp_udp_socket_drop(int32_t handle); + +void udp_udp_socket_drop_own(udp_own_udp_socket_t handle) { + __wasm_import_udp_udp_socket_drop(handle.__handle); +} + +void udp_udp_socket_drop_borrow(udp_borrow_udp_socket_t handle) { + __wasm_import_udp_udp_socket_drop(handle.__handle); +} + +udp_borrow_udp_socket_t udp_borrow_udp_socket(udp_own_udp_socket_t arg) { + return (udp_borrow_udp_socket_t) { arg.__handle }; +} + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[resource-drop]incoming-datagram-stream"))) +extern void __wasm_import_udp_incoming_datagram_stream_drop(int32_t handle); + +void udp_incoming_datagram_stream_drop_own(udp_own_incoming_datagram_stream_t handle) { + __wasm_import_udp_incoming_datagram_stream_drop(handle.__handle); +} + +void udp_incoming_datagram_stream_drop_borrow(udp_borrow_incoming_datagram_stream_t handle) { + __wasm_import_udp_incoming_datagram_stream_drop(handle.__handle); +} + +udp_borrow_incoming_datagram_stream_t udp_borrow_incoming_datagram_stream(udp_own_incoming_datagram_stream_t arg) { + return (udp_borrow_incoming_datagram_stream_t) { arg.__handle }; +} + +__attribute__((__import_module__("wasi:sockets/udp@0.2.0"), __import_name__("[resource-drop]outgoing-datagram-stream"))) +extern void __wasm_import_udp_outgoing_datagram_stream_drop(int32_t handle); + +void udp_outgoing_datagram_stream_drop_own(udp_own_outgoing_datagram_stream_t handle) { + __wasm_import_udp_outgoing_datagram_stream_drop(handle.__handle); +} + +void udp_outgoing_datagram_stream_drop_borrow(udp_borrow_outgoing_datagram_stream_t handle) { + __wasm_import_udp_outgoing_datagram_stream_drop(handle.__handle); +} + +udp_borrow_outgoing_datagram_stream_t udp_borrow_outgoing_datagram_stream(udp_own_outgoing_datagram_stream_t arg) { + return (udp_borrow_outgoing_datagram_stream_t) { arg.__handle }; +} + +void udp_result_void_error_code_free(udp_result_void_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void udp_result_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_error_code_free(udp_result_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void udp_result_ip_socket_address_error_code_free(udp_result_ip_socket_address_error_code_t *ptr) { + if (!ptr->is_err) { + udp_ip_socket_address_free(&ptr->val.ok); + } else { + } +} + +void udp_result_u8_error_code_free(udp_result_u8_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void udp_result_u64_error_code_free(udp_result_u64_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void udp_list_incoming_datagram_free(udp_list_incoming_datagram_t *ptr) { + for (size_t i = 0; i < ptr->len; i++) { + udp_incoming_datagram_free(&ptr->ptr[i]); + } + if (ptr->len > 0) { + free(ptr->ptr); + } +} + +void udp_result_list_incoming_datagram_error_code_free(udp_result_list_incoming_datagram_error_code_t *ptr) { + if (!ptr->is_err) { + udp_list_incoming_datagram_free(&ptr->val.ok); + } else { + } +} + +void udp_list_outgoing_datagram_free(udp_list_outgoing_datagram_t *ptr) { + for (size_t i = 0; i < ptr->len; i++) { + udp_outgoing_datagram_free(&ptr->ptr[i]); + } + if (ptr->len > 0) { + free(ptr->ptr); + } +} + +void udp_create_socket_result_own_udp_socket_error_code_free(udp_create_socket_result_own_udp_socket_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void tcp_ip_socket_address_free(tcp_ip_socket_address_t *ptr) { + network_ip_socket_address_free(ptr); +} + +__attribute__((__import_module__("wasi:sockets/tcp@0.2.0"), __import_name__("[resource-drop]tcp-socket"))) +extern void __wasm_import_tcp_tcp_socket_drop(int32_t handle); + +void tcp_tcp_socket_drop_own(tcp_own_tcp_socket_t handle) { + __wasm_import_tcp_tcp_socket_drop(handle.__handle); +} + +void tcp_tcp_socket_drop_borrow(tcp_borrow_tcp_socket_t handle) { + __wasm_import_tcp_tcp_socket_drop(handle.__handle); +} + +tcp_borrow_tcp_socket_t tcp_borrow_tcp_socket(tcp_own_tcp_socket_t arg) { + return (tcp_borrow_tcp_socket_t) { arg.__handle }; +} + +void tcp_result_void_error_code_free(tcp_result_void_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void tcp_result_tuple2_own_input_stream_own_output_stream_error_code_free(tcp_result_tuple2_own_input_stream_own_output_stream_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void tcp_result_tuple3_own_tcp_socket_own_input_stream_own_output_stream_error_code_free(tcp_result_tuple3_own_tcp_socket_own_input_stream_own_output_stream_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void tcp_result_ip_socket_address_error_code_free(tcp_result_ip_socket_address_error_code_t *ptr) { + if (!ptr->is_err) { + tcp_ip_socket_address_free(&ptr->val.ok); + } else { + } +} + +void tcp_result_bool_error_code_free(tcp_result_bool_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void tcp_result_duration_error_code_free(tcp_result_duration_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void tcp_result_u32_error_code_free(tcp_result_u32_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void tcp_result_u8_error_code_free(tcp_result_u8_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void tcp_result_u64_error_code_free(tcp_result_u64_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void tcp_create_socket_result_own_tcp_socket_error_code_free(tcp_create_socket_result_own_tcp_socket_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void ip_name_lookup_ip_address_free(ip_name_lookup_ip_address_t *ptr) { + network_ip_address_free(ptr); +} + +__attribute__((__import_module__("wasi:sockets/ip-name-lookup@0.2.0"), __import_name__("[resource-drop]resolve-address-stream"))) +extern void __wasm_import_ip_name_lookup_resolve_address_stream_drop(int32_t handle); + +void ip_name_lookup_resolve_address_stream_drop_own(ip_name_lookup_own_resolve_address_stream_t handle) { + __wasm_import_ip_name_lookup_resolve_address_stream_drop(handle.__handle); +} + +void ip_name_lookup_resolve_address_stream_drop_borrow(ip_name_lookup_borrow_resolve_address_stream_t handle) { + __wasm_import_ip_name_lookup_resolve_address_stream_drop(handle.__handle); +} + +ip_name_lookup_borrow_resolve_address_stream_t ip_name_lookup_borrow_resolve_address_stream(ip_name_lookup_own_resolve_address_stream_t arg) { + return (ip_name_lookup_borrow_resolve_address_stream_t) { arg.__handle }; +} + +void ip_name_lookup_result_own_resolve_address_stream_error_code_free(ip_name_lookup_result_own_resolve_address_stream_error_code_t *ptr) { + if (!ptr->is_err) { + } else { + } +} + +void ip_name_lookup_option_ip_address_free(ip_name_lookup_option_ip_address_t *ptr) { + if (ptr->is_some) { + ip_name_lookup_ip_address_free(&ptr->val); + } +} + +void ip_name_lookup_result_option_ip_address_error_code_free(ip_name_lookup_result_option_ip_address_error_code_t *ptr) { + if (!ptr->is_err) { + ip_name_lookup_option_ip_address_free(&ptr->val.ok); + } else { + } +} + +void wasip2_string_set(wasip2_string_t *ret, char*s) { + ret->ptr = (uint8_t*) s; + ret->len = strlen(s); +} + +void wasip2_string_dup(wasip2_string_t *ret, const char*s) { + ret->len = strlen(s); + ret->ptr = cabi_realloc(NULL, 0, 1, ret->len * 1); + memcpy(ret->ptr, s, ret->len * 1); +} + +void wasip2_string_free(wasip2_string_t *ret) { + if (ret->len > 0) { + free(ret->ptr); + } + ret->ptr = NULL; + ret->len = 0; +} + +// Component Adapters + +void environment_get_environment(wasip2_list_tuple2_string_string_t *ret) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_environment_get_environment(ptr); + *ret = (wasip2_list_tuple2_string_string_t) { (wasip2_tuple2_string_string_t*)(*((int32_t*) (ptr + 0))), (size_t)(*((int32_t*) (ptr + 4))) }; +} + +void environment_get_arguments(wasip2_list_string_t *ret) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_environment_get_arguments(ptr); + *ret = (wasip2_list_string_t) { (wasip2_string_t*)(*((int32_t*) (ptr + 0))), (size_t)(*((int32_t*) (ptr + 4))) }; +} + +bool environment_initial_cwd(wasip2_string_t *ret) { + __attribute__((__aligned__(4))) + uint8_t ret_area[12]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_environment_initial_cwd(ptr); + wasip2_option_string_t option; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + option.is_some = false; + break; + } + case 1: { + option.is_some = true; + option.val = (wasip2_string_t) { (uint8_t*)(*((int32_t*) (ptr + 4))), (size_t)(*((int32_t*) (ptr + 8))) }; + break; + } + } + *ret = option.val; + return option.is_some; +} + +void exit_exit(exit_result_void_void_t *status) { + int32_t result; + if ((*status).is_err) { + result = 1; + } else { + result = 0; + } + __wasm_import_exit_exit(result); +} + +void io_error_method_error_to_debug_string(io_error_borrow_error_t self, wasip2_string_t *ret) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_io_error_method_error_to_debug_string((self).__handle, ptr); + *ret = (wasip2_string_t) { (uint8_t*)(*((int32_t*) (ptr + 0))), (size_t)(*((int32_t*) (ptr + 4))) }; +} + +bool poll_method_pollable_ready(poll_borrow_pollable_t self) { + int32_t ret = __wasm_import_poll_method_pollable_ready((self).__handle); + return ret; +} + +void poll_method_pollable_block(poll_borrow_pollable_t self) { + __wasm_import_poll_method_pollable_block((self).__handle); +} + +void poll_poll(poll_list_borrow_pollable_t *in, wasip2_list_u32_t *ret) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_poll_poll((int32_t) (*in).ptr, (int32_t) (*in).len, ptr); + *ret = (wasip2_list_u32_t) { (uint32_t*)(*((int32_t*) (ptr + 0))), (size_t)(*((int32_t*) (ptr + 4))) }; +} + +bool streams_method_input_stream_read(streams_borrow_input_stream_t self, uint64_t len, wasip2_list_u8_t *ret, streams_stream_error_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[12]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_streams_method_input_stream_read((self).__handle, (int64_t) (len), ptr); + streams_result_list_u8_stream_error_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (wasip2_list_u8_t) { (uint8_t*)(*((int32_t*) (ptr + 4))), (size_t)(*((int32_t*) (ptr + 8))) }; + break; + } + case 1: { + result.is_err = true; + streams_stream_error_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 4))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 8)) }; + break; + } + case 1: { + break; + } + } + + result.val.err = variant; + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool streams_method_input_stream_blocking_read(streams_borrow_input_stream_t self, uint64_t len, wasip2_list_u8_t *ret, streams_stream_error_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[12]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_streams_method_input_stream_blocking_read((self).__handle, (int64_t) (len), ptr); + streams_result_list_u8_stream_error_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (wasip2_list_u8_t) { (uint8_t*)(*((int32_t*) (ptr + 4))), (size_t)(*((int32_t*) (ptr + 8))) }; + break; + } + case 1: { + result.is_err = true; + streams_stream_error_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 4))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 8)) }; + break; + } + case 1: { + break; + } + } + + result.val.err = variant; + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool streams_method_input_stream_skip(streams_borrow_input_stream_t self, uint64_t len, uint64_t *ret, streams_stream_error_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_streams_method_input_stream_skip((self).__handle, (int64_t) (len), ptr); + streams_result_u64_stream_error_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8))); + break; + } + case 1: { + result.is_err = true; + streams_stream_error_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 8))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 12)) }; + break; + } + case 1: { + break; + } + } + + result.val.err = variant; + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool streams_method_input_stream_blocking_skip(streams_borrow_input_stream_t self, uint64_t len, uint64_t *ret, streams_stream_error_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_streams_method_input_stream_blocking_skip((self).__handle, (int64_t) (len), ptr); + streams_result_u64_stream_error_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8))); + break; + } + case 1: { + result.is_err = true; + streams_stream_error_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 8))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 12)) }; + break; + } + case 1: { + break; + } + } + + result.val.err = variant; + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +streams_own_pollable_t streams_method_input_stream_subscribe(streams_borrow_input_stream_t self) { + int32_t ret = __wasm_import_streams_method_input_stream_subscribe((self).__handle); + return (streams_own_pollable_t) { ret }; +} + +bool streams_method_output_stream_check_write(streams_borrow_output_stream_t self, uint64_t *ret, streams_stream_error_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_streams_method_output_stream_check_write((self).__handle, ptr); + streams_result_u64_stream_error_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8))); + break; + } + case 1: { + result.is_err = true; + streams_stream_error_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 8))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 12)) }; + break; + } + case 1: { + break; + } + } + + result.val.err = variant; + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool streams_method_output_stream_write(streams_borrow_output_stream_t self, wasip2_list_u8_t *contents, streams_stream_error_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[12]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_streams_method_output_stream_write((self).__handle, (int32_t) (*contents).ptr, (int32_t) (*contents).len, ptr); + streams_result_void_stream_error_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + streams_stream_error_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 4))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 8)) }; + break; + } + case 1: { + break; + } + } + + result.val.err = variant; + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool streams_method_output_stream_blocking_write_and_flush(streams_borrow_output_stream_t self, wasip2_list_u8_t *contents, streams_stream_error_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[12]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_streams_method_output_stream_blocking_write_and_flush((self).__handle, (int32_t) (*contents).ptr, (int32_t) (*contents).len, ptr); + streams_result_void_stream_error_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + streams_stream_error_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 4))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 8)) }; + break; + } + case 1: { + break; + } + } + + result.val.err = variant; + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool streams_method_output_stream_flush(streams_borrow_output_stream_t self, streams_stream_error_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[12]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_streams_method_output_stream_flush((self).__handle, ptr); + streams_result_void_stream_error_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + streams_stream_error_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 4))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 8)) }; + break; + } + case 1: { + break; + } + } + + result.val.err = variant; + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool streams_method_output_stream_blocking_flush(streams_borrow_output_stream_t self, streams_stream_error_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[12]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_streams_method_output_stream_blocking_flush((self).__handle, ptr); + streams_result_void_stream_error_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + streams_stream_error_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 4))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 8)) }; + break; + } + case 1: { + break; + } + } + + result.val.err = variant; + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +streams_own_pollable_t streams_method_output_stream_subscribe(streams_borrow_output_stream_t self) { + int32_t ret = __wasm_import_streams_method_output_stream_subscribe((self).__handle); + return (streams_own_pollable_t) { ret }; +} + +bool streams_method_output_stream_write_zeroes(streams_borrow_output_stream_t self, uint64_t len, streams_stream_error_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[12]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_streams_method_output_stream_write_zeroes((self).__handle, (int64_t) (len), ptr); + streams_result_void_stream_error_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + streams_stream_error_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 4))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 8)) }; + break; + } + case 1: { + break; + } + } + + result.val.err = variant; + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool streams_method_output_stream_blocking_write_zeroes_and_flush(streams_borrow_output_stream_t self, uint64_t len, streams_stream_error_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[12]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_streams_method_output_stream_blocking_write_zeroes_and_flush((self).__handle, (int64_t) (len), ptr); + streams_result_void_stream_error_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + streams_stream_error_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 4))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 8)) }; + break; + } + case 1: { + break; + } + } + + result.val.err = variant; + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool streams_method_output_stream_splice(streams_borrow_output_stream_t self, streams_borrow_input_stream_t src, uint64_t len, uint64_t *ret, streams_stream_error_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_streams_method_output_stream_splice((self).__handle, (src).__handle, (int64_t) (len), ptr); + streams_result_u64_stream_error_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8))); + break; + } + case 1: { + result.is_err = true; + streams_stream_error_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 8))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 12)) }; + break; + } + case 1: { + break; + } + } + + result.val.err = variant; + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool streams_method_output_stream_blocking_splice(streams_borrow_output_stream_t self, streams_borrow_input_stream_t src, uint64_t len, uint64_t *ret, streams_stream_error_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_streams_method_output_stream_blocking_splice((self).__handle, (src).__handle, (int64_t) (len), ptr); + streams_result_u64_stream_error_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8))); + break; + } + case 1: { + result.is_err = true; + streams_stream_error_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 8))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.last_operation_failed = (streams_own_error_t) { *((int32_t*) (ptr + 12)) }; + break; + } + case 1: { + break; + } + } + + result.val.err = variant; + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +stdin_own_input_stream_t stdin_get_stdin(void) { + int32_t ret = __wasm_import_stdin_get_stdin(); + return (stdin_own_input_stream_t) { ret }; +} + +stdout_own_output_stream_t stdout_get_stdout(void) { + int32_t ret = __wasm_import_stdout_get_stdout(); + return (stdout_own_output_stream_t) { ret }; +} + +stderr_own_output_stream_t stderr_get_stderr(void) { + int32_t ret = __wasm_import_stderr_get_stderr(); + return (stderr_own_output_stream_t) { ret }; +} + +bool terminal_stdin_get_terminal_stdin(terminal_stdin_own_terminal_input_t *ret) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_terminal_stdin_get_terminal_stdin(ptr); + terminal_stdin_option_own_terminal_input_t option; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + option.is_some = false; + break; + } + case 1: { + option.is_some = true; + option.val = (terminal_stdin_own_terminal_input_t) { *((int32_t*) (ptr + 4)) }; + break; + } + } + *ret = option.val; + return option.is_some; +} + +bool terminal_stdout_get_terminal_stdout(terminal_stdout_own_terminal_output_t *ret) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_terminal_stdout_get_terminal_stdout(ptr); + terminal_stdout_option_own_terminal_output_t option; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + option.is_some = false; + break; + } + case 1: { + option.is_some = true; + option.val = (terminal_stdout_own_terminal_output_t) { *((int32_t*) (ptr + 4)) }; + break; + } + } + *ret = option.val; + return option.is_some; +} + +bool terminal_stderr_get_terminal_stderr(terminal_stderr_own_terminal_output_t *ret) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_terminal_stderr_get_terminal_stderr(ptr); + terminal_stderr_option_own_terminal_output_t option; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + option.is_some = false; + break; + } + case 1: { + option.is_some = true; + option.val = (terminal_stderr_own_terminal_output_t) { *((int32_t*) (ptr + 4)) }; + break; + } + } + *ret = option.val; + return option.is_some; +} + +monotonic_clock_instant_t monotonic_clock_now(void) { + int64_t ret = __wasm_import_monotonic_clock_now(); + return (uint64_t) (ret); +} + +monotonic_clock_duration_t monotonic_clock_resolution(void) { + int64_t ret = __wasm_import_monotonic_clock_resolution(); + return (uint64_t) (ret); +} + +monotonic_clock_own_pollable_t monotonic_clock_subscribe_instant(monotonic_clock_instant_t when) { + int32_t ret = __wasm_import_monotonic_clock_subscribe_instant((int64_t) (when)); + return (monotonic_clock_own_pollable_t) { ret }; +} + +monotonic_clock_own_pollable_t monotonic_clock_subscribe_duration(monotonic_clock_duration_t when) { + int32_t ret = __wasm_import_monotonic_clock_subscribe_duration((int64_t) (when)); + return (monotonic_clock_own_pollable_t) { ret }; +} + +void wall_clock_now(wall_clock_datetime_t *ret) { + __attribute__((__aligned__(8))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_wall_clock_now(ptr); + *ret = (wall_clock_datetime_t) { + (uint64_t) (*((int64_t*) (ptr + 0))), + (uint32_t) (*((int32_t*) (ptr + 8))), + }; +} + +void wall_clock_resolution(wall_clock_datetime_t *ret) { + __attribute__((__aligned__(8))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_wall_clock_resolution(ptr); + *ret = (wall_clock_datetime_t) { + (uint64_t) (*((int64_t*) (ptr + 0))), + (uint32_t) (*((int32_t*) (ptr + 8))), + }; +} + +bool filesystem_method_descriptor_read_via_stream(filesystem_borrow_descriptor_t self, filesystem_filesize_t offset, filesystem_own_input_stream_t *ret, filesystem_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_read_via_stream((self).__handle, (int64_t) (offset), ptr); + filesystem_result_own_input_stream_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (filesystem_own_input_stream_t) { *((int32_t*) (ptr + 4)) }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_write_via_stream(filesystem_borrow_descriptor_t self, filesystem_filesize_t offset, filesystem_own_output_stream_t *ret, filesystem_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_write_via_stream((self).__handle, (int64_t) (offset), ptr); + filesystem_result_own_output_stream_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (filesystem_own_output_stream_t) { *((int32_t*) (ptr + 4)) }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_append_via_stream(filesystem_borrow_descriptor_t self, filesystem_own_output_stream_t *ret, filesystem_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_append_via_stream((self).__handle, ptr); + filesystem_result_own_output_stream_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (filesystem_own_output_stream_t) { *((int32_t*) (ptr + 4)) }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_advise(filesystem_borrow_descriptor_t self, filesystem_filesize_t offset, filesystem_filesize_t length, filesystem_advice_t advice, filesystem_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_advise((self).__handle, (int64_t) (offset), (int64_t) (length), (int32_t) advice, ptr); + filesystem_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_sync_data(filesystem_borrow_descriptor_t self, filesystem_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_sync_data((self).__handle, ptr); + filesystem_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_get_flags(filesystem_borrow_descriptor_t self, filesystem_descriptor_flags_t *ret, filesystem_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_get_flags((self).__handle, ptr); + filesystem_result_descriptor_flags_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_get_type(filesystem_borrow_descriptor_t self, filesystem_descriptor_type_t *ret, filesystem_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_get_type((self).__handle, ptr); + filesystem_result_descriptor_type_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_set_size(filesystem_borrow_descriptor_t self, filesystem_filesize_t size, filesystem_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_set_size((self).__handle, (int64_t) (size), ptr); + filesystem_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_set_times(filesystem_borrow_descriptor_t self, filesystem_new_timestamp_t *data_access_timestamp, filesystem_new_timestamp_t *data_modification_timestamp, filesystem_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t variant; + int64_t variant2; + int32_t variant3; + switch ((int32_t) (*data_access_timestamp).tag) { + case 0: { + variant = 0; + variant2 = 0; + variant3 = 0; + break; + } + case 1: { + variant = 1; + variant2 = 0; + variant3 = 0; + break; + } + case 2: { + const filesystem_datetime_t *payload1 = &(*data_access_timestamp).val.timestamp; + variant = 2; + variant2 = (int64_t) ((*payload1).seconds); + variant3 = (int32_t) ((*payload1).nanoseconds); + break; + } + } + int32_t variant7; + int64_t variant8; + int32_t variant9; + switch ((int32_t) (*data_modification_timestamp).tag) { + case 0: { + variant7 = 0; + variant8 = 0; + variant9 = 0; + break; + } + case 1: { + variant7 = 1; + variant8 = 0; + variant9 = 0; + break; + } + case 2: { + const filesystem_datetime_t *payload6 = &(*data_modification_timestamp).val.timestamp; + variant7 = 2; + variant8 = (int64_t) ((*payload6).seconds); + variant9 = (int32_t) ((*payload6).nanoseconds); + break; + } + } + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_set_times((self).__handle, variant, variant2, variant3, variant7, variant8, variant9, ptr); + filesystem_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_read(filesystem_borrow_descriptor_t self, filesystem_filesize_t length, filesystem_filesize_t offset, wasip2_tuple2_list_u8_bool_t *ret, filesystem_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_read((self).__handle, (int64_t) (length), (int64_t) (offset), ptr); + filesystem_result_tuple2_list_u8_bool_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (wasip2_tuple2_list_u8_bool_t) { + (wasip2_list_u8_t) { (uint8_t*)(*((int32_t*) (ptr + 4))), (size_t)(*((int32_t*) (ptr + 8))) }, + (int32_t) (*((uint8_t*) (ptr + 12))), + }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_write(filesystem_borrow_descriptor_t self, wasip2_list_u8_t *buffer, filesystem_filesize_t offset, filesystem_filesize_t *ret, filesystem_error_code_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_write((self).__handle, (int32_t) (*buffer).ptr, (int32_t) (*buffer).len, (int64_t) (offset), ptr); + filesystem_result_filesize_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8))); + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 8))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_read_directory(filesystem_borrow_descriptor_t self, filesystem_own_directory_entry_stream_t *ret, filesystem_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_read_directory((self).__handle, ptr); + filesystem_result_own_directory_entry_stream_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (filesystem_own_directory_entry_stream_t) { *((int32_t*) (ptr + 4)) }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_sync(filesystem_borrow_descriptor_t self, filesystem_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_sync((self).__handle, ptr); + filesystem_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_create_directory_at(filesystem_borrow_descriptor_t self, wasip2_string_t *path, filesystem_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_create_directory_at((self).__handle, (int32_t) (*path).ptr, (int32_t) (*path).len, ptr); + filesystem_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_stat(filesystem_borrow_descriptor_t self, filesystem_descriptor_stat_t *ret, filesystem_error_code_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[104]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_stat((self).__handle, ptr); + filesystem_result_descriptor_stat_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + filesystem_option_datetime_t option; + switch ((int32_t) (*((uint8_t*) (ptr + 32)))) { + case 0: { + option.is_some = false; + break; + } + case 1: { + option.is_some = true; + option.val = (wall_clock_datetime_t) { + (uint64_t) (*((int64_t*) (ptr + 40))), + (uint32_t) (*((int32_t*) (ptr + 48))), + }; + break; + } + } + filesystem_option_datetime_t option0; + switch ((int32_t) (*((uint8_t*) (ptr + 56)))) { + case 0: { + option0.is_some = false; + break; + } + case 1: { + option0.is_some = true; + option0.val = (wall_clock_datetime_t) { + (uint64_t) (*((int64_t*) (ptr + 64))), + (uint32_t) (*((int32_t*) (ptr + 72))), + }; + break; + } + } + filesystem_option_datetime_t option1; + switch ((int32_t) (*((uint8_t*) (ptr + 80)))) { + case 0: { + option1.is_some = false; + break; + } + case 1: { + option1.is_some = true; + option1.val = (wall_clock_datetime_t) { + (uint64_t) (*((int64_t*) (ptr + 88))), + (uint32_t) (*((int32_t*) (ptr + 96))), + }; + break; + } + } + + result.val.ok = (filesystem_descriptor_stat_t) { + (int32_t) (*((uint8_t*) (ptr + 8))), + (uint64_t) (*((int64_t*) (ptr + 16))), + (uint64_t) (*((int64_t*) (ptr + 24))), + option, + option0, + option1, + }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 8))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_stat_at(filesystem_borrow_descriptor_t self, filesystem_path_flags_t path_flags, wasip2_string_t *path, filesystem_descriptor_stat_t *ret, filesystem_error_code_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[104]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_stat_at((self).__handle, path_flags, (int32_t) (*path).ptr, (int32_t) (*path).len, ptr); + filesystem_result_descriptor_stat_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + filesystem_option_datetime_t option; + switch ((int32_t) (*((uint8_t*) (ptr + 32)))) { + case 0: { + option.is_some = false; + break; + } + case 1: { + option.is_some = true; + option.val = (wall_clock_datetime_t) { + (uint64_t) (*((int64_t*) (ptr + 40))), + (uint32_t) (*((int32_t*) (ptr + 48))), + }; + break; + } + } + filesystem_option_datetime_t option0; + switch ((int32_t) (*((uint8_t*) (ptr + 56)))) { + case 0: { + option0.is_some = false; + break; + } + case 1: { + option0.is_some = true; + option0.val = (wall_clock_datetime_t) { + (uint64_t) (*((int64_t*) (ptr + 64))), + (uint32_t) (*((int32_t*) (ptr + 72))), + }; + break; + } + } + filesystem_option_datetime_t option1; + switch ((int32_t) (*((uint8_t*) (ptr + 80)))) { + case 0: { + option1.is_some = false; + break; + } + case 1: { + option1.is_some = true; + option1.val = (wall_clock_datetime_t) { + (uint64_t) (*((int64_t*) (ptr + 88))), + (uint32_t) (*((int32_t*) (ptr + 96))), + }; + break; + } + } + + result.val.ok = (filesystem_descriptor_stat_t) { + (int32_t) (*((uint8_t*) (ptr + 8))), + (uint64_t) (*((int64_t*) (ptr + 16))), + (uint64_t) (*((int64_t*) (ptr + 24))), + option, + option0, + option1, + }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 8))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_set_times_at(filesystem_borrow_descriptor_t self, filesystem_path_flags_t path_flags, wasip2_string_t *path, filesystem_new_timestamp_t *data_access_timestamp, filesystem_new_timestamp_t *data_modification_timestamp, filesystem_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t variant; + int64_t variant2; + int32_t variant3; + switch ((int32_t) (*data_access_timestamp).tag) { + case 0: { + variant = 0; + variant2 = 0; + variant3 = 0; + break; + } + case 1: { + variant = 1; + variant2 = 0; + variant3 = 0; + break; + } + case 2: { + const filesystem_datetime_t *payload1 = &(*data_access_timestamp).val.timestamp; + variant = 2; + variant2 = (int64_t) ((*payload1).seconds); + variant3 = (int32_t) ((*payload1).nanoseconds); + break; + } + } + int32_t variant7; + int64_t variant8; + int32_t variant9; + switch ((int32_t) (*data_modification_timestamp).tag) { + case 0: { + variant7 = 0; + variant8 = 0; + variant9 = 0; + break; + } + case 1: { + variant7 = 1; + variant8 = 0; + variant9 = 0; + break; + } + case 2: { + const filesystem_datetime_t *payload6 = &(*data_modification_timestamp).val.timestamp; + variant7 = 2; + variant8 = (int64_t) ((*payload6).seconds); + variant9 = (int32_t) ((*payload6).nanoseconds); + break; + } + } + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_set_times_at((self).__handle, path_flags, (int32_t) (*path).ptr, (int32_t) (*path).len, variant, variant2, variant3, variant7, variant8, variant9, ptr); + filesystem_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_link_at(filesystem_borrow_descriptor_t self, filesystem_path_flags_t old_path_flags, wasip2_string_t *old_path, filesystem_borrow_descriptor_t new_descriptor, wasip2_string_t *new_path, filesystem_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_link_at((self).__handle, old_path_flags, (int32_t) (*old_path).ptr, (int32_t) (*old_path).len, (new_descriptor).__handle, (int32_t) (*new_path).ptr, (int32_t) (*new_path).len, ptr); + filesystem_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_open_at(filesystem_borrow_descriptor_t self, filesystem_path_flags_t path_flags, wasip2_string_t *path, filesystem_open_flags_t open_flags, filesystem_descriptor_flags_t flags, filesystem_own_descriptor_t *ret, filesystem_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_open_at((self).__handle, path_flags, (int32_t) (*path).ptr, (int32_t) (*path).len, open_flags, flags, ptr); + filesystem_result_own_descriptor_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (filesystem_own_descriptor_t) { *((int32_t*) (ptr + 4)) }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_readlink_at(filesystem_borrow_descriptor_t self, wasip2_string_t *path, wasip2_string_t *ret, filesystem_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[12]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_readlink_at((self).__handle, (int32_t) (*path).ptr, (int32_t) (*path).len, ptr); + filesystem_result_string_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (wasip2_string_t) { (uint8_t*)(*((int32_t*) (ptr + 4))), (size_t)(*((int32_t*) (ptr + 8))) }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_remove_directory_at(filesystem_borrow_descriptor_t self, wasip2_string_t *path, filesystem_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_remove_directory_at((self).__handle, (int32_t) (*path).ptr, (int32_t) (*path).len, ptr); + filesystem_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_rename_at(filesystem_borrow_descriptor_t self, wasip2_string_t *old_path, filesystem_borrow_descriptor_t new_descriptor, wasip2_string_t *new_path, filesystem_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_rename_at((self).__handle, (int32_t) (*old_path).ptr, (int32_t) (*old_path).len, (new_descriptor).__handle, (int32_t) (*new_path).ptr, (int32_t) (*new_path).len, ptr); + filesystem_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_symlink_at(filesystem_borrow_descriptor_t self, wasip2_string_t *old_path, wasip2_string_t *new_path, filesystem_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_symlink_at((self).__handle, (int32_t) (*old_path).ptr, (int32_t) (*old_path).len, (int32_t) (*new_path).ptr, (int32_t) (*new_path).len, ptr); + filesystem_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_unlink_file_at(filesystem_borrow_descriptor_t self, wasip2_string_t *path, filesystem_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_unlink_file_at((self).__handle, (int32_t) (*path).ptr, (int32_t) (*path).len, ptr); + filesystem_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_is_same_object(filesystem_borrow_descriptor_t self, filesystem_borrow_descriptor_t other) { + int32_t ret = __wasm_import_filesystem_method_descriptor_is_same_object((self).__handle, (other).__handle); + return ret; +} + +bool filesystem_method_descriptor_metadata_hash(filesystem_borrow_descriptor_t self, filesystem_metadata_hash_value_t *ret, filesystem_error_code_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[24]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_metadata_hash((self).__handle, ptr); + filesystem_result_metadata_hash_value_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (filesystem_metadata_hash_value_t) { + (uint64_t) (*((int64_t*) (ptr + 8))), + (uint64_t) (*((int64_t*) (ptr + 16))), + }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 8))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_descriptor_metadata_hash_at(filesystem_borrow_descriptor_t self, filesystem_path_flags_t path_flags, wasip2_string_t *path, filesystem_metadata_hash_value_t *ret, filesystem_error_code_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[24]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_descriptor_metadata_hash_at((self).__handle, path_flags, (int32_t) (*path).ptr, (int32_t) (*path).len, ptr); + filesystem_result_metadata_hash_value_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (filesystem_metadata_hash_value_t) { + (uint64_t) (*((int64_t*) (ptr + 8))), + (uint64_t) (*((int64_t*) (ptr + 16))), + }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 8))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_method_directory_entry_stream_read_directory_entry(filesystem_borrow_directory_entry_stream_t self, filesystem_option_directory_entry_t *ret, filesystem_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[20]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_method_directory_entry_stream_read_directory_entry((self).__handle, ptr); + filesystem_result_option_directory_entry_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + filesystem_option_directory_entry_t option; + switch ((int32_t) (*((uint8_t*) (ptr + 4)))) { + case 0: { + option.is_some = false; + break; + } + case 1: { + option.is_some = true; + option.val = (filesystem_directory_entry_t) { + (int32_t) (*((uint8_t*) (ptr + 8))), + (wasip2_string_t) { (uint8_t*)(*((int32_t*) (ptr + 12))), (size_t)(*((int32_t*) (ptr + 16))) }, + }; + break; + } + } + + result.val.ok = option; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool filesystem_filesystem_error_code(filesystem_borrow_error_t err_, filesystem_error_code_t *ret) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_filesystem_error_code((err_).__handle, ptr); + filesystem_option_error_code_t option; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + option.is_some = false; + break; + } + case 1: { + option.is_some = true; + option.val = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + *ret = option.val; + return option.is_some; +} + +void filesystem_preopens_get_directories(filesystem_preopens_list_tuple2_own_descriptor_string_t *ret) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_filesystem_preopens_get_directories(ptr); + *ret = (filesystem_preopens_list_tuple2_own_descriptor_string_t) { (filesystem_preopens_tuple2_own_descriptor_string_t*)(*((int32_t*) (ptr + 0))), (size_t)(*((int32_t*) (ptr + 4))) }; +} + +instance_network_own_network_t instance_network_instance_network(void) { + int32_t ret = __wasm_import_instance_network_instance_network(); + return (instance_network_own_network_t) { ret }; +} + +bool udp_method_udp_socket_start_bind(udp_borrow_udp_socket_t self, udp_borrow_network_t network, udp_ip_socket_address_t *local_address, udp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t variant; + int32_t variant1; + int32_t variant2; + int32_t variant3; + int32_t variant4; + int32_t variant5; + int32_t variant6; + int32_t variant7; + int32_t variant8; + int32_t variant9; + int32_t variant10; + int32_t variant11; + switch ((int32_t) (*local_address).tag) { + case 0: { + const network_ipv4_socket_address_t *payload = &(*local_address).val.ipv4; + variant = 0; + variant1 = (int32_t) ((*payload).port); + variant2 = (int32_t) (((*payload).address).f0); + variant3 = (int32_t) (((*payload).address).f1); + variant4 = (int32_t) (((*payload).address).f2); + variant5 = (int32_t) (((*payload).address).f3); + variant6 = 0; + variant7 = 0; + variant8 = 0; + variant9 = 0; + variant10 = 0; + variant11 = 0; + break; + } + case 1: { + const network_ipv6_socket_address_t *payload0 = &(*local_address).val.ipv6; + variant = 1; + variant1 = (int32_t) ((*payload0).port); + variant2 = (int32_t) ((*payload0).flow_info); + variant3 = (int32_t) (((*payload0).address).f0); + variant4 = (int32_t) (((*payload0).address).f1); + variant5 = (int32_t) (((*payload0).address).f2); + variant6 = (int32_t) (((*payload0).address).f3); + variant7 = (int32_t) (((*payload0).address).f4); + variant8 = (int32_t) (((*payload0).address).f5); + variant9 = (int32_t) (((*payload0).address).f6); + variant10 = (int32_t) (((*payload0).address).f7); + variant11 = (int32_t) ((*payload0).scope_id); + break; + } + } + int32_t ptr = (int32_t) &ret_area; + __wasm_import_udp_method_udp_socket_start_bind((self).__handle, (network).__handle, variant, variant1, variant2, variant3, variant4, variant5, variant6, variant7, variant8, variant9, variant10, variant11, ptr); + udp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool udp_method_udp_socket_finish_bind(udp_borrow_udp_socket_t self, udp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_udp_method_udp_socket_finish_bind((self).__handle, ptr); + udp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool udp_method_udp_socket_stream(udp_borrow_udp_socket_t self, udp_ip_socket_address_t *maybe_remote_address, udp_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_t *ret, udp_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[12]; + udp_option_ip_socket_address_t remote_address; + remote_address.is_some = maybe_remote_address != NULL;if (maybe_remote_address) { + remote_address.val = *maybe_remote_address; + } + int32_t option; + int32_t option14; + int32_t option15; + int32_t option16; + int32_t option17; + int32_t option18; + int32_t option19; + int32_t option20; + int32_t option21; + int32_t option22; + int32_t option23; + int32_t option24; + int32_t option25; + if ((remote_address).is_some) { + const udp_ip_socket_address_t *payload0 = &(remote_address).val; + int32_t variant; + int32_t variant3; + int32_t variant4; + int32_t variant5; + int32_t variant6; + int32_t variant7; + int32_t variant8; + int32_t variant9; + int32_t variant10; + int32_t variant11; + int32_t variant12; + int32_t variant13; + switch ((int32_t) (*payload0).tag) { + case 0: { + const network_ipv4_socket_address_t *payload1 = &(*payload0).val.ipv4; + variant = 0; + variant3 = (int32_t) ((*payload1).port); + variant4 = (int32_t) (((*payload1).address).f0); + variant5 = (int32_t) (((*payload1).address).f1); + variant6 = (int32_t) (((*payload1).address).f2); + variant7 = (int32_t) (((*payload1).address).f3); + variant8 = 0; + variant9 = 0; + variant10 = 0; + variant11 = 0; + variant12 = 0; + variant13 = 0; + break; + } + case 1: { + const network_ipv6_socket_address_t *payload2 = &(*payload0).val.ipv6; + variant = 1; + variant3 = (int32_t) ((*payload2).port); + variant4 = (int32_t) ((*payload2).flow_info); + variant5 = (int32_t) (((*payload2).address).f0); + variant6 = (int32_t) (((*payload2).address).f1); + variant7 = (int32_t) (((*payload2).address).f2); + variant8 = (int32_t) (((*payload2).address).f3); + variant9 = (int32_t) (((*payload2).address).f4); + variant10 = (int32_t) (((*payload2).address).f5); + variant11 = (int32_t) (((*payload2).address).f6); + variant12 = (int32_t) (((*payload2).address).f7); + variant13 = (int32_t) ((*payload2).scope_id); + break; + } + } + option = 1; + option14 = variant; + option15 = variant3; + option16 = variant4; + option17 = variant5; + option18 = variant6; + option19 = variant7; + option20 = variant8; + option21 = variant9; + option22 = variant10; + option23 = variant11; + option24 = variant12; + option25 = variant13; + } else { + option = 0; + option14 = 0; + option15 = 0; + option16 = 0; + option17 = 0; + option18 = 0; + option19 = 0; + option20 = 0; + option21 = 0; + option22 = 0; + option23 = 0; + option24 = 0; + option25 = 0; + } + int32_t ptr = (int32_t) &ret_area; + __wasm_import_udp_method_udp_socket_stream((self).__handle, option, option14, option15, option16, option17, option18, option19, option20, option21, option22, option23, option24, option25, ptr); + udp_result_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (udp_tuple2_own_incoming_datagram_stream_own_outgoing_datagram_stream_t) { + (udp_own_incoming_datagram_stream_t) { *((int32_t*) (ptr + 4)) }, + (udp_own_outgoing_datagram_stream_t) { *((int32_t*) (ptr + 8)) }, + }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool udp_method_udp_socket_local_address(udp_borrow_udp_socket_t self, udp_ip_socket_address_t *ret, udp_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[36]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_udp_method_udp_socket_local_address((self).__handle, ptr); + udp_result_ip_socket_address_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + network_ip_socket_address_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 4))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.ipv4 = (network_ipv4_socket_address_t) { + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))), + (network_ipv4_address_t) { + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 10)))), + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 11)))), + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 12)))), + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 13)))), + }, + }; + break; + } + case 1: { + variant.val.ipv6 = (network_ipv6_socket_address_t) { + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))), + (uint32_t) (*((int32_t*) (ptr + 12))), + (network_ipv6_address_t) { + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 16)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 18)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 20)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 22)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 24)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 26)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 28)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 30)))), + }, + (uint32_t) (*((int32_t*) (ptr + 32))), + }; + break; + } + } + + result.val.ok = variant; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool udp_method_udp_socket_remote_address(udp_borrow_udp_socket_t self, udp_ip_socket_address_t *ret, udp_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[36]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_udp_method_udp_socket_remote_address((self).__handle, ptr); + udp_result_ip_socket_address_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + network_ip_socket_address_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 4))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.ipv4 = (network_ipv4_socket_address_t) { + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))), + (network_ipv4_address_t) { + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 10)))), + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 11)))), + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 12)))), + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 13)))), + }, + }; + break; + } + case 1: { + variant.val.ipv6 = (network_ipv6_socket_address_t) { + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))), + (uint32_t) (*((int32_t*) (ptr + 12))), + (network_ipv6_address_t) { + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 16)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 18)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 20)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 22)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 24)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 26)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 28)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 30)))), + }, + (uint32_t) (*((int32_t*) (ptr + 32))), + }; + break; + } + } + + result.val.ok = variant; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +udp_ip_address_family_t udp_method_udp_socket_address_family(udp_borrow_udp_socket_t self) { + int32_t ret = __wasm_import_udp_method_udp_socket_address_family((self).__handle); + return ret; +} + +bool udp_method_udp_socket_unicast_hop_limit(udp_borrow_udp_socket_t self, uint8_t *ret, udp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_udp_method_udp_socket_unicast_hop_limit((self).__handle, ptr); + udp_result_u8_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 1)))); + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool udp_method_udp_socket_set_unicast_hop_limit(udp_borrow_udp_socket_t self, uint8_t value, udp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_udp_method_udp_socket_set_unicast_hop_limit((self).__handle, (int32_t) (value), ptr); + udp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool udp_method_udp_socket_receive_buffer_size(udp_borrow_udp_socket_t self, uint64_t *ret, udp_error_code_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_udp_method_udp_socket_receive_buffer_size((self).__handle, ptr); + udp_result_u64_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8))); + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 8))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool udp_method_udp_socket_set_receive_buffer_size(udp_borrow_udp_socket_t self, uint64_t value, udp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_udp_method_udp_socket_set_receive_buffer_size((self).__handle, (int64_t) (value), ptr); + udp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool udp_method_udp_socket_send_buffer_size(udp_borrow_udp_socket_t self, uint64_t *ret, udp_error_code_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_udp_method_udp_socket_send_buffer_size((self).__handle, ptr); + udp_result_u64_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8))); + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 8))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool udp_method_udp_socket_set_send_buffer_size(udp_borrow_udp_socket_t self, uint64_t value, udp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_udp_method_udp_socket_set_send_buffer_size((self).__handle, (int64_t) (value), ptr); + udp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +udp_own_pollable_t udp_method_udp_socket_subscribe(udp_borrow_udp_socket_t self) { + int32_t ret = __wasm_import_udp_method_udp_socket_subscribe((self).__handle); + return (udp_own_pollable_t) { ret }; +} + +bool udp_method_incoming_datagram_stream_receive(udp_borrow_incoming_datagram_stream_t self, uint64_t max_results, udp_list_incoming_datagram_t *ret, udp_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[12]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_udp_method_incoming_datagram_stream_receive((self).__handle, (int64_t) (max_results), ptr); + udp_result_list_incoming_datagram_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (udp_list_incoming_datagram_t) { (udp_incoming_datagram_t*)(*((int32_t*) (ptr + 4))), (size_t)(*((int32_t*) (ptr + 8))) }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +udp_own_pollable_t udp_method_incoming_datagram_stream_subscribe(udp_borrow_incoming_datagram_stream_t self) { + int32_t ret = __wasm_import_udp_method_incoming_datagram_stream_subscribe((self).__handle); + return (udp_own_pollable_t) { ret }; +} + +bool udp_method_outgoing_datagram_stream_check_send(udp_borrow_outgoing_datagram_stream_t self, uint64_t *ret, udp_error_code_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_udp_method_outgoing_datagram_stream_check_send((self).__handle, ptr); + udp_result_u64_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8))); + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 8))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool udp_method_outgoing_datagram_stream_send(udp_borrow_outgoing_datagram_stream_t self, udp_list_outgoing_datagram_t *datagrams, uint64_t *ret, udp_error_code_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_udp_method_outgoing_datagram_stream_send((self).__handle, (int32_t) (*datagrams).ptr, (int32_t) (*datagrams).len, ptr); + udp_result_u64_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8))); + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 8))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +udp_own_pollable_t udp_method_outgoing_datagram_stream_subscribe(udp_borrow_outgoing_datagram_stream_t self) { + int32_t ret = __wasm_import_udp_method_outgoing_datagram_stream_subscribe((self).__handle); + return (udp_own_pollable_t) { ret }; +} + +bool udp_create_socket_create_udp_socket(udp_create_socket_ip_address_family_t address_family, udp_create_socket_own_udp_socket_t *ret, udp_create_socket_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_udp_create_socket_create_udp_socket((int32_t) address_family, ptr); + udp_create_socket_result_own_udp_socket_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (udp_create_socket_own_udp_socket_t) { *((int32_t*) (ptr + 4)) }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_start_bind(tcp_borrow_tcp_socket_t self, tcp_borrow_network_t network, tcp_ip_socket_address_t *local_address, tcp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t variant; + int32_t variant1; + int32_t variant2; + int32_t variant3; + int32_t variant4; + int32_t variant5; + int32_t variant6; + int32_t variant7; + int32_t variant8; + int32_t variant9; + int32_t variant10; + int32_t variant11; + switch ((int32_t) (*local_address).tag) { + case 0: { + const network_ipv4_socket_address_t *payload = &(*local_address).val.ipv4; + variant = 0; + variant1 = (int32_t) ((*payload).port); + variant2 = (int32_t) (((*payload).address).f0); + variant3 = (int32_t) (((*payload).address).f1); + variant4 = (int32_t) (((*payload).address).f2); + variant5 = (int32_t) (((*payload).address).f3); + variant6 = 0; + variant7 = 0; + variant8 = 0; + variant9 = 0; + variant10 = 0; + variant11 = 0; + break; + } + case 1: { + const network_ipv6_socket_address_t *payload0 = &(*local_address).val.ipv6; + variant = 1; + variant1 = (int32_t) ((*payload0).port); + variant2 = (int32_t) ((*payload0).flow_info); + variant3 = (int32_t) (((*payload0).address).f0); + variant4 = (int32_t) (((*payload0).address).f1); + variant5 = (int32_t) (((*payload0).address).f2); + variant6 = (int32_t) (((*payload0).address).f3); + variant7 = (int32_t) (((*payload0).address).f4); + variant8 = (int32_t) (((*payload0).address).f5); + variant9 = (int32_t) (((*payload0).address).f6); + variant10 = (int32_t) (((*payload0).address).f7); + variant11 = (int32_t) ((*payload0).scope_id); + break; + } + } + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_start_bind((self).__handle, (network).__handle, variant, variant1, variant2, variant3, variant4, variant5, variant6, variant7, variant8, variant9, variant10, variant11, ptr); + tcp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_finish_bind(tcp_borrow_tcp_socket_t self, tcp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_finish_bind((self).__handle, ptr); + tcp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_start_connect(tcp_borrow_tcp_socket_t self, tcp_borrow_network_t network, tcp_ip_socket_address_t *remote_address, tcp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t variant; + int32_t variant1; + int32_t variant2; + int32_t variant3; + int32_t variant4; + int32_t variant5; + int32_t variant6; + int32_t variant7; + int32_t variant8; + int32_t variant9; + int32_t variant10; + int32_t variant11; + switch ((int32_t) (*remote_address).tag) { + case 0: { + const network_ipv4_socket_address_t *payload = &(*remote_address).val.ipv4; + variant = 0; + variant1 = (int32_t) ((*payload).port); + variant2 = (int32_t) (((*payload).address).f0); + variant3 = (int32_t) (((*payload).address).f1); + variant4 = (int32_t) (((*payload).address).f2); + variant5 = (int32_t) (((*payload).address).f3); + variant6 = 0; + variant7 = 0; + variant8 = 0; + variant9 = 0; + variant10 = 0; + variant11 = 0; + break; + } + case 1: { + const network_ipv6_socket_address_t *payload0 = &(*remote_address).val.ipv6; + variant = 1; + variant1 = (int32_t) ((*payload0).port); + variant2 = (int32_t) ((*payload0).flow_info); + variant3 = (int32_t) (((*payload0).address).f0); + variant4 = (int32_t) (((*payload0).address).f1); + variant5 = (int32_t) (((*payload0).address).f2); + variant6 = (int32_t) (((*payload0).address).f3); + variant7 = (int32_t) (((*payload0).address).f4); + variant8 = (int32_t) (((*payload0).address).f5); + variant9 = (int32_t) (((*payload0).address).f6); + variant10 = (int32_t) (((*payload0).address).f7); + variant11 = (int32_t) ((*payload0).scope_id); + break; + } + } + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_start_connect((self).__handle, (network).__handle, variant, variant1, variant2, variant3, variant4, variant5, variant6, variant7, variant8, variant9, variant10, variant11, ptr); + tcp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_finish_connect(tcp_borrow_tcp_socket_t self, tcp_tuple2_own_input_stream_own_output_stream_t *ret, tcp_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[12]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_finish_connect((self).__handle, ptr); + tcp_result_tuple2_own_input_stream_own_output_stream_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (tcp_tuple2_own_input_stream_own_output_stream_t) { + (tcp_own_input_stream_t) { *((int32_t*) (ptr + 4)) }, + (tcp_own_output_stream_t) { *((int32_t*) (ptr + 8)) }, + }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_start_listen(tcp_borrow_tcp_socket_t self, tcp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_start_listen((self).__handle, ptr); + tcp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_finish_listen(tcp_borrow_tcp_socket_t self, tcp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_finish_listen((self).__handle, ptr); + tcp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_accept(tcp_borrow_tcp_socket_t self, tcp_tuple3_own_tcp_socket_own_input_stream_own_output_stream_t *ret, tcp_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_accept((self).__handle, ptr); + tcp_result_tuple3_own_tcp_socket_own_input_stream_own_output_stream_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (tcp_tuple3_own_tcp_socket_own_input_stream_own_output_stream_t) { + (tcp_own_tcp_socket_t) { *((int32_t*) (ptr + 4)) }, + (tcp_own_input_stream_t) { *((int32_t*) (ptr + 8)) }, + (tcp_own_output_stream_t) { *((int32_t*) (ptr + 12)) }, + }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_local_address(tcp_borrow_tcp_socket_t self, tcp_ip_socket_address_t *ret, tcp_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[36]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_local_address((self).__handle, ptr); + tcp_result_ip_socket_address_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + network_ip_socket_address_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 4))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.ipv4 = (network_ipv4_socket_address_t) { + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))), + (network_ipv4_address_t) { + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 10)))), + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 11)))), + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 12)))), + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 13)))), + }, + }; + break; + } + case 1: { + variant.val.ipv6 = (network_ipv6_socket_address_t) { + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))), + (uint32_t) (*((int32_t*) (ptr + 12))), + (network_ipv6_address_t) { + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 16)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 18)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 20)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 22)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 24)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 26)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 28)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 30)))), + }, + (uint32_t) (*((int32_t*) (ptr + 32))), + }; + break; + } + } + + result.val.ok = variant; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_remote_address(tcp_borrow_tcp_socket_t self, tcp_ip_socket_address_t *ret, tcp_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[36]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_remote_address((self).__handle, ptr); + tcp_result_ip_socket_address_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + network_ip_socket_address_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 4))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.ipv4 = (network_ipv4_socket_address_t) { + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))), + (network_ipv4_address_t) { + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 10)))), + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 11)))), + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 12)))), + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 13)))), + }, + }; + break; + } + case 1: { + variant.val.ipv6 = (network_ipv6_socket_address_t) { + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))), + (uint32_t) (*((int32_t*) (ptr + 12))), + (network_ipv6_address_t) { + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 16)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 18)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 20)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 22)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 24)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 26)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 28)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 30)))), + }, + (uint32_t) (*((int32_t*) (ptr + 32))), + }; + break; + } + } + + result.val.ok = variant; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_is_listening(tcp_borrow_tcp_socket_t self) { + int32_t ret = __wasm_import_tcp_method_tcp_socket_is_listening((self).__handle); + return ret; +} + +tcp_ip_address_family_t tcp_method_tcp_socket_address_family(tcp_borrow_tcp_socket_t self) { + int32_t ret = __wasm_import_tcp_method_tcp_socket_address_family((self).__handle); + return ret; +} + +bool tcp_method_tcp_socket_set_listen_backlog_size(tcp_borrow_tcp_socket_t self, uint64_t value, tcp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_set_listen_backlog_size((self).__handle, (int64_t) (value), ptr); + tcp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_keep_alive_enabled(tcp_borrow_tcp_socket_t self, bool *ret, tcp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_keep_alive_enabled((self).__handle, ptr); + tcp_result_bool_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_set_keep_alive_enabled(tcp_borrow_tcp_socket_t self, bool value, tcp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_set_keep_alive_enabled((self).__handle, value, ptr); + tcp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_keep_alive_idle_time(tcp_borrow_tcp_socket_t self, tcp_duration_t *ret, tcp_error_code_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_keep_alive_idle_time((self).__handle, ptr); + tcp_result_duration_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8))); + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 8))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_set_keep_alive_idle_time(tcp_borrow_tcp_socket_t self, tcp_duration_t value, tcp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_set_keep_alive_idle_time((self).__handle, (int64_t) (value), ptr); + tcp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_keep_alive_interval(tcp_borrow_tcp_socket_t self, tcp_duration_t *ret, tcp_error_code_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_keep_alive_interval((self).__handle, ptr); + tcp_result_duration_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8))); + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 8))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_set_keep_alive_interval(tcp_borrow_tcp_socket_t self, tcp_duration_t value, tcp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_set_keep_alive_interval((self).__handle, (int64_t) (value), ptr); + tcp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_keep_alive_count(tcp_borrow_tcp_socket_t self, uint32_t *ret, tcp_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_keep_alive_count((self).__handle, ptr); + tcp_result_u32_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (uint32_t) (*((int32_t*) (ptr + 4))); + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_set_keep_alive_count(tcp_borrow_tcp_socket_t self, uint32_t value, tcp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_set_keep_alive_count((self).__handle, (int32_t) (value), ptr); + tcp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_hop_limit(tcp_borrow_tcp_socket_t self, uint8_t *ret, tcp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_hop_limit((self).__handle, ptr); + tcp_result_u8_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 1)))); + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_set_hop_limit(tcp_borrow_tcp_socket_t self, uint8_t value, tcp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_set_hop_limit((self).__handle, (int32_t) (value), ptr); + tcp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_receive_buffer_size(tcp_borrow_tcp_socket_t self, uint64_t *ret, tcp_error_code_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_receive_buffer_size((self).__handle, ptr); + tcp_result_u64_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8))); + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 8))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_set_receive_buffer_size(tcp_borrow_tcp_socket_t self, uint64_t value, tcp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_set_receive_buffer_size((self).__handle, (int64_t) (value), ptr); + tcp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_send_buffer_size(tcp_borrow_tcp_socket_t self, uint64_t *ret, tcp_error_code_t *err) { + __attribute__((__aligned__(8))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_send_buffer_size((self).__handle, ptr); + tcp_result_u64_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (uint64_t) (*((int64_t*) (ptr + 8))); + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 8))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_method_tcp_socket_set_send_buffer_size(tcp_borrow_tcp_socket_t self, uint64_t value, tcp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_set_send_buffer_size((self).__handle, (int64_t) (value), ptr); + tcp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +tcp_own_pollable_t tcp_method_tcp_socket_subscribe(tcp_borrow_tcp_socket_t self) { + int32_t ret = __wasm_import_tcp_method_tcp_socket_subscribe((self).__handle); + return (tcp_own_pollable_t) { ret }; +} + +bool tcp_method_tcp_socket_shutdown(tcp_borrow_tcp_socket_t self, tcp_shutdown_type_t shutdown_type, tcp_error_code_t *err) { + __attribute__((__aligned__(1))) + uint8_t ret_area[2]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_method_tcp_socket_shutdown((self).__handle, (int32_t) shutdown_type, ptr); + tcp_result_void_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 1))); + break; + } + } + if (!result.is_err) { + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool tcp_create_socket_create_tcp_socket(tcp_create_socket_ip_address_family_t address_family, tcp_create_socket_own_tcp_socket_t *ret, tcp_create_socket_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_tcp_create_socket_create_tcp_socket((int32_t) address_family, ptr); + tcp_create_socket_result_own_tcp_socket_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (tcp_create_socket_own_tcp_socket_t) { *((int32_t*) (ptr + 4)) }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool ip_name_lookup_resolve_addresses(ip_name_lookup_borrow_network_t network, wasip2_string_t *name, ip_name_lookup_own_resolve_address_stream_t *ret, ip_name_lookup_error_code_t *err) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_ip_name_lookup_resolve_addresses((network).__handle, (int32_t) (*name).ptr, (int32_t) (*name).len, ptr); + ip_name_lookup_result_own_resolve_address_stream_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + result.val.ok = (ip_name_lookup_own_resolve_address_stream_t) { *((int32_t*) (ptr + 4)) }; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 4))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +bool ip_name_lookup_method_resolve_address_stream_resolve_next_address(ip_name_lookup_borrow_resolve_address_stream_t self, ip_name_lookup_option_ip_address_t *ret, ip_name_lookup_error_code_t *err) { + __attribute__((__aligned__(2))) + uint8_t ret_area[22]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_ip_name_lookup_method_resolve_address_stream_resolve_next_address((self).__handle, ptr); + ip_name_lookup_result_option_ip_address_error_code_t result; + switch ((int32_t) (*((uint8_t*) (ptr + 0)))) { + case 0: { + result.is_err = false; + ip_name_lookup_option_ip_address_t option; + switch ((int32_t) (*((uint8_t*) (ptr + 2)))) { + case 0: { + option.is_some = false; + break; + } + case 1: { + option.is_some = true; + network_ip_address_t variant; + variant.tag = (int32_t) (*((uint8_t*) (ptr + 4))); + switch ((int32_t) variant.tag) { + case 0: { + variant.val.ipv4 = (network_ipv4_address_t) { + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 6)))), + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 7)))), + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 8)))), + (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 9)))), + }; + break; + } + case 1: { + variant.val.ipv6 = (network_ipv6_address_t) { + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 6)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 10)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 12)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 14)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 16)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 18)))), + (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 20)))), + }; + break; + } + } + + option.val = variant; + break; + } + } + + result.val.ok = option; + break; + } + case 1: { + result.is_err = true; + result.val.err = (int32_t) (*((uint8_t*) (ptr + 2))); + break; + } + } + if (!result.is_err) { + *ret = result.val.ok; + return 1; + } else { + *err = result.val.err; + return 0; + } +} + +ip_name_lookup_own_pollable_t ip_name_lookup_method_resolve_address_stream_subscribe(ip_name_lookup_borrow_resolve_address_stream_t self) { + int32_t ret = __wasm_import_ip_name_lookup_method_resolve_address_stream_subscribe((self).__handle); + return (ip_name_lookup_own_pollable_t) { ret }; +} + +void random_get_random_bytes(uint64_t len, wasip2_list_u8_t *ret) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_random_get_random_bytes((int64_t) (len), ptr); + *ret = (wasip2_list_u8_t) { (uint8_t*)(*((int32_t*) (ptr + 0))), (size_t)(*((int32_t*) (ptr + 4))) }; +} + +uint64_t random_get_random_u64(void) { + int64_t ret = __wasm_import_random_get_random_u64(); + return (uint64_t) (ret); +} + +void random_insecure_get_insecure_random_bytes(uint64_t len, wasip2_list_u8_t *ret) { + __attribute__((__aligned__(4))) + uint8_t ret_area[8]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_random_insecure_get_insecure_random_bytes((int64_t) (len), ptr); + *ret = (wasip2_list_u8_t) { (uint8_t*)(*((int32_t*) (ptr + 0))), (size_t)(*((int32_t*) (ptr + 4))) }; +} + +uint64_t random_insecure_get_insecure_random_u64(void) { + int64_t ret = __wasm_import_random_insecure_get_insecure_random_u64(); + return (uint64_t) (ret); +} + +void random_insecure_seed_insecure_seed(wasip2_tuple2_u64_u64_t *ret) { + __attribute__((__aligned__(8))) + uint8_t ret_area[16]; + int32_t ptr = (int32_t) &ret_area; + __wasm_import_random_insecure_seed_insecure_seed(ptr); + *ret = (wasip2_tuple2_u64_u64_t) { + (uint64_t) (*((int64_t*) (ptr + 0))), + (uint64_t) (*((int64_t*) (ptr + 8))), + }; +} + +extern void __component_type_object_force_link_wasip2(void); +void __component_type_object_force_link_wasip2_public_use_in_this_compilation_unit(void) { + __component_type_object_force_link_wasip2(); +} diff --git a/libc-bottom-half/sources/wasip2_component_type.o b/libc-bottom-half/sources/wasip2_component_type.o Binary files differnew file mode 100644 index 0000000..0548e3e --- /dev/null +++ b/libc-bottom-half/sources/wasip2_component_type.o |