tinygo-org/tinygo
1
0
Fork 0
mirror of https://github.com/tinygo-org/tinygo.git synced 2026-07-26 06:38:42 +00:00
Code Issues Packages Projects Releases 6 Wiki Activity

wasi preview 2 support (#4027)

Browse Source 
* all: wasip2 support

Co-authored-by: Randy Reddig <randy.reddig@fastly.com>
This commit is contained in:
Damian Gryski
2024-07-02 07:02:03 -07:00
committed by GitHub
parent f18c6e342f
commit 9cb263479c
125 changed files with 7035 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.github/workflows/linux.yml
+13 -11
View File
@@ -134,17 +134,19 @@ jobs:
steps:
- name: Checkout
uses: actions/checkout@v4
with:
submodules: true
- name: Install Go
uses: actions/setup-go@v5
with:
go-version: '1.22'
cache: true
- name: Install wasmtime
run: |
mkdir -p $HOME/.wasmtime $HOME/.wasmtime/bin
curl https://github.com/bytecodealliance/wasmtime/releases/download/v14.0.4/wasmtime-v14.0.4-x86_64-linux.tar.xz -o wasmtime-v14.0.4-x86_64-linux.tar.xz -SfL
tar -C $HOME/.wasmtime/bin --wildcards -xf wasmtime-v14.0.4-x86_64-linux.tar.xz --strip-components=1 wasmtime-v14.0.4-x86_64-linux/*
echo "$HOME/.wasmtime/bin" >> $GITHUB_PATH
uses: bytecodealliance/actions/wasmtime/setup@v1
with:
version: "19.0.1"
- name: Install wasm-tools
uses: bytecodealliance/actions/wasm-tools/setup@v1
- name: Download release artifact
uses: actions/download-artifact@v4
with:
@@ -154,8 +156,8 @@ jobs:
mkdir -p ~/lib
tar -C ~/lib -xf tinygo.linux-amd64.tar.gz
ln -s ~/lib/tinygo/bin/tinygo ~/go/bin/tinygo
- run: make tinygo-test-wasi-fast
- run: make tinygo-test-wasip1-fast
- run: make tinygo-test-wasip2-fast
- run: make smoketest
assert-test-linux:
# Run all tests that can run on Linux, with LLVM assertions enabled to catch
@@ -187,11 +189,11 @@ jobs:
with:
node-version: '18'
- name: Install wasmtime
run: |
mkdir -p $HOME/.wasmtime $HOME/.wasmtime/bin
curl -L https://github.com/bytecodealliance/wasmtime/releases/download/v14.0.4/wasmtime-v14.0.4-x86_64-linux.tar.xz -o wasmtime-v14.0.4-x86_64-linux.tar.xz -SfL
tar -C $HOME/.wasmtime/bin --wildcards -xf wasmtime-v14.0.4-x86_64-linux.tar.xz --strip-components=1 wasmtime-v14.0.4-x86_64-linux/*
echo "$HOME/.wasmtime/bin" >> $GITHUB_PATH
uses: bytecodealliance/actions/wasmtime/setup@v1
with:
version: "19.0.1"
- name: Setup `wasm-tools`
uses: bytecodealliance/actions/wasm-tools/setup@v1
- name: Restore LLVM source cache
uses: actions/cache/restore@v4
id: cache-llvm-source
.github/workflows/windows.yml
+2 -2
View File
@@ -220,5 +220,5 @@ jobs:
shell: bash
working-directory: build
run: 7z x release.zip -r
- name: Test stdlib packages on wasi
run: make tinygo-test-wasi-fast TINYGO=$(PWD)/build/tinygo/bin/tinygo
- name: Test stdlib packages on wasip1
run: make tinygo-test-wasip1-fast TINYGO=$(PWD)/build/tinygo/bin/tinygo
.gitignore
+4 -1
View File
@@ -1,3 +1,6 @@
go.work
go.work.sum
docs/_build
src/device/avr/*.go
src/device/avr/*.ld
@@ -17,7 +20,7 @@ src/device/kendryte/*.go
src/device/kendryte/*.s
src/device/rp/*.go
src/device/rp/*.s
vendor
./vendor
llvm-build
llvm-project
build/*
.gitmodules
+6
View File
@@ -39,3 +39,9 @@
path = src/net
url = https://github.com/tinygo-org/net.git
branch = dev
[submodule "lib/wasi-cli"]
path = lib/wasi-cli
url = https://github.com/WebAssembly/wasi-cli
[submodule "src/vendor/github.com/ydnar/wasm-tools-go"]
path = src/vendor/github.com/ydnar/wasm-tools-go
url = https://github.com/ydnar/wasm-tools-go.git
GNUmakefile
+33 -5
View File
@@ -268,6 +268,11 @@ lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a:
@if [ ! -e lib/wasi-libc/Makefile ]; then echo "Submodules have not been downloaded. Please download them using:\n git submodule update --init"; exit 1; fi
cd lib/wasi-libc && $(MAKE) -j4 EXTRA_CFLAGS="-O2 -g -DNDEBUG -mnontrapping-fptoint -msign-ext" MALLOC_IMPL=none CC="$(CLANG)" AR=$(LLVM_AR) NM=$(LLVM_NM)
# Generate WASI syscall bindings
.PHONY: wasi-syscall
wasi-syscall:
wit-bindgen-go generate -o ./src/internal -p internal --versioned ./lib/wasi-cli/wit
# Check for Node.js used during WASM tests.
NODEJS_VERSION := $(word 1,$(subst ., ,$(shell node -v | cut -c 2-)))
MIN_NODEJS_VERSION=18
@@ -430,15 +435,36 @@ tinygo-test-wasi:
$(TINYGO) test -target wasip1 $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_SLOW) ./tests/runtime_wasi
tinygo-test-wasip1:
GOOS=wasip1 GOARCH=wasm $(TINYGO) test $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_SLOW) ./tests/runtime_wasi
tinygo-test-wasi-fast:
$(TINYGO) test -target wasip1 $(TEST_PACKAGES_FAST) ./tests/runtime_wasi
tinygo-test-wasip1-fast:
GOOS=wasip1 GOARCH=wasm $(TINYGO) test $(TEST_PACKAGES_FAST) ./tests/runtime_wasi
tinygo-bench-wasi:
$(TINYGO) test -target=wasip1 $(TEST_PACKAGES_FAST) ./tests/runtime_wasi
tinygo-test-wasip2-slow:
$(TINYGO) test -target=wasip2 $(TEST_PACKAGES_SLOW)
tinygo-test-wasip2-fast:
$(TINYGO) test -target=wasip2 $(TEST_PACKAGES_FAST) ./tests/runtime_wasi
tinygo-test-wasip2-sum-slow:
TINYGO=$(TINYGO) \
TARGET=wasip2 \
TESTOPTS="-x -work" \
PACKAGES="$(TEST_PACKAGES_SLOW)" \
gotestsum --raw-command -- ./tools/tgtestjson.sh
tinygo-test-wasip2-sum-fast:
TINYGO=$(TINYGO) \
TARGET=wasip2 \
TESTOPTS="-x -work" \
PACKAGES="$(TEST_PACKAGES_FAST)" \
gotestsum --raw-command -- ./tools/tgtestjson.sh
tinygo-bench-wasip1:
$(TINYGO) test -target wasip1 -bench . $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_SLOW)
tinygo-bench-wasi-fast:
tinygo-bench-wasip1-fast:
$(TINYGO) test -target wasip1 -bench . $(TEST_PACKAGES_FAST)
tinygo-bench-wasip2:
$(TINYGO) test -target wasip2 -bench . $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_SLOW)
tinygo-bench-wasip2-fast:
$(TINYGO) test -target wasip2 -bench . $(TEST_PACKAGES_FAST)
# Test external packages in a large corpus.
test-corpus:
CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test $(GOTESTFLAGS) -timeout=1h -buildmode exe -tags byollvm -run TestCorpus . -corpus=testdata/corpus.yaml
@@ -832,6 +858,7 @@ build/release: tinygo gen-device wasi-libc $(if $(filter 1,$(USE_SYSTEM_BINARYEN
@mkdir -p build/release/tinygo/lib/wasi-libc/libc-bottom-half/headers
@mkdir -p build/release/tinygo/lib/wasi-libc/libc-top-half/musl/arch
@mkdir -p build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
@mkdir -p build/release/tinygo/lib/wasi-cli/
@mkdir -p build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0
@mkdir -p build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0plus
@mkdir -p build/release/tinygo/pkg/thumbv7em-unknown-unknown-eabi-cortex-m4
@@ -891,6 +918,7 @@ endif
@cp -rp lib/wasi-libc/libc-top-half/musl/src/string build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
@cp -rp lib/wasi-libc/libc-top-half/musl/include build/release/tinygo/lib/wasi-libc/libc-top-half/musl
@cp -rp lib/wasi-libc/sysroot build/release/tinygo/lib/wasi-libc/sysroot
@cp -rp lib/wasi-cli/wit build/release/tinygo/lib/wasi-cli/wit
@cp -rp llvm-project/compiler-rt/lib/builtins build/release/tinygo/lib/compiler-rt-builtins
@cp -rp llvm-project/compiler-rt/LICENSE.TXT build/release/tinygo/lib/compiler-rt-builtins
@cp -rp src build/release/tinygo/src
builder/build.go
+59 -3
View File
@@ -840,11 +840,11 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
"--output", result.Executable,
)
wasmopt := goenv.Get("WASMOPT")
if config.Options.PrintCommands != nil {
config.Options.PrintCommands(goenv.Get("WASMOPT"), args...)
config.Options.PrintCommands(wasmopt, args...)
}
cmd := exec.Command(goenv.Get("WASMOPT"), args...)
cmd := exec.Command(wasmopt, args...)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
@@ -854,6 +854,62 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
}
}
// Run wasm-tools for component-model binaries
witPackage := strings.ReplaceAll(config.Target.WITPackage, "{root}", goenv.Get("TINYGOROOT"))
if config.Options.WITPackage != "" {
witPackage = config.Options.WITPackage
}
witWorld := config.Target.WITWorld
if config.Options.WITWorld != "" {
witWorld = config.Options.WITWorld
}
if witPackage != "" && witWorld != "" {
// wasm-tools component embed -w wasi:cli/command
// $$(tinygo env TINYGOROOT)/lib/wasi-cli/wit/ main.wasm -o embedded.wasm
args := []string{
"component",
"embed",
"-w", witWorld,
witPackage,
result.Executable,
"-o", result.Executable,
}
wasmtools := goenv.Get("WASMTOOLS")
if config.Options.PrintCommands != nil {
config.Options.PrintCommands(wasmtools, args...)
}
cmd := exec.Command(wasmtools, args...)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
err := cmd.Run()
if err != nil {
return fmt.Errorf("wasm-tools failed: %w", err)
}
// wasm-tools component new embedded.wasm -o component.wasm
args = []string{
"component",
"new",
result.Executable,
"-o", result.Executable,
}
if config.Options.PrintCommands != nil {
config.Options.PrintCommands(wasmtools, args...)
}
cmd = exec.Command(wasmtools, args...)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
err = cmd.Run()
if err != nil {
return fmt.Errorf("wasm-tools failed: %w", err)
}
}
// Print code size if requested.
if config.Options.PrintSizes == "short" || config.Options.PrintSizes == "full" {
packagePathMap := make(map[string]string, len(lprogram.Packages))
builder/builder_test.go
+2
View File
@@ -34,6 +34,7 @@ func TestClangAttributes(t *testing.T) {
"nintendoswitch",
"riscv-qemu",
"wasip1",
"wasip2",
"wasm",
"wasm-unknown",
}
@@ -61,6 +62,7 @@ func TestClangAttributes(t *testing.T) {
{GOOS: "windows", GOARCH: "amd64"},
{GOOS: "windows", GOARCH: "arm64"},
{GOOS: "wasip1", GOARCH: "wasm"},
{GOOS: "wasip2", GOARCH: "wasm"},
} {
name := "GOOS=" + options.GOOS + ",GOARCH=" + options.GOARCH
if options.GOARCH == "arm" {
compileopts/options.go
+2
View File
@@ -53,6 +53,8 @@ type Options struct {
Monitor bool
BaudRate int
Timeout time.Duration
WITPackage string // pass through to wasm-tools component embed invocation
WITWorld string // pass through to wasm-tools component embed -w option
}
// Verify performs a validation on the given options, raising an error if options are not valid.
compileopts/target.go
+2
View File
@@ -62,6 +62,8 @@ type TargetSpec struct {
JLinkDevice string `json:"jlink-device,omitempty"`
CodeModel string `json:"code-model,omitempty"`
RelocationModel string `json:"relocation-model,omitempty"`
WITPackage string `json:"wit-package,omitempty"`
WITWorld string `json:"wit-world,omitempty"`
}
// overrideProperties overrides all properties that are set in child into itself using reflection.
compiler/symbol.go
+39 -9
View File
@@ -346,7 +346,7 @@ func (c *compilerContext) parsePragmas(info *functionInfo, f *ssa.Function) {
// The list of allowed types is based on this proposal:
// https://github.com/golang/go/issues/59149
func (c *compilerContext) checkWasmImport(f *ssa.Function, pragma string) {
if c.pkg.Path() == "runtime" || c.pkg.Path() == "syscall/js" {
if c.pkg.Path() == "runtime" || c.pkg.Path() == "syscall/js" || c.pkg.Path() == "syscall" {
// The runtime is a special case. Allow all kinds of parameters
// (importantly, including pointers).
return
@@ -360,38 +360,68 @@ func (c *compilerContext) checkWasmImport(f *ssa.Function, pragma string) {
c.addError(f.Signature.Results().At(1).Pos(), fmt.Sprintf("%s: too many return values", pragma))
} else if f.Signature.Results().Len() == 1 {
result := f.Signature.Results().At(0)
if !isValidWasmType(result.Type(), true) {
if !isValidWasmType(result.Type(), siteResult) {
c.addError(result.Pos(), fmt.Sprintf("%s: unsupported result type %s", pragma, result.Type().String()))
}
}
for _, param := range f.Params {
// Check whether the type is allowed.
// Only a very limited number of types can be mapped to WebAssembly.
if !isValidWasmType(param.Type(), false) {
if !isValidWasmType(param.Type(), siteParam) {
c.addError(param.Pos(), fmt.Sprintf("%s: unsupported parameter type %s", pragma, param.Type().String()))
}
}
}
// Check whether the type maps directly to a WebAssembly type, according to:
// Check whether the type maps directly to a WebAssembly type.
//
// This reflects the relaxed type restrictions proposed here (except for structs.HostLayout):
// https://github.com/golang/go/issues/66984
//
// This previously reflected the additional restrictions documented here:
// https://github.com/golang/go/issues/59149
func isValidWasmType(typ types.Type, isReturn bool) bool {
func isValidWasmType(typ types.Type, site wasmSite) bool {
switch typ := typ.Underlying().(type) {
case *types.Basic:
switch typ.Kind() {
case types.Int32, types.Uint32, types.Int64, types.Uint64:
case types.Bool:
return true
case types.Int, types.Uint, types.Int8, types.Uint8, types.Int16, types.Uint16, types.Int32, types.Uint32, types.Int64, types.Uint64:
return true
case types.Float32, types.Float64:
return true
case types.UnsafePointer:
if !isReturn {
return true
case types.Uintptr, types.UnsafePointer:
return true
case types.String:
// string flattens to two values, so disallowed as a result
return site == siteParam || site == siteIndirect
}
case *types.Array:
return site == siteIndirect && isValidWasmType(typ.Elem(), siteIndirect)
case *types.Struct:
if site != siteIndirect {
return false
}
for i := 0; i < typ.NumFields(); i++ {
if !isValidWasmType(typ.Field(i).Type(), siteIndirect) {
return false
}
}
return true
case *types.Pointer:
return isValidWasmType(typ.Elem(), siteIndirect)
}
return false
}
type wasmSite int
const (
siteParam wasmSite = iota
siteResult
siteIndirect // pointer or field
)
// getParams returns the function parameters, including the receiver at the
// start. This is an alternative to the Params member of *ssa.Function, which is
// not yet populated when the package has not yet been built.
compiler/testdata/errors.go
Vendored
+48 -14
View File
@@ -13,31 +13,65 @@ func implementation() {
type Uint uint32
//go:wasmimport modulename validparam
func validparam(a int32, b uint64, c float64, d unsafe.Pointer, e Uint)
type S struct {
a [4]uint32
b uintptr
c int
d float32
e float64
}
// ERROR: //go:wasmimport modulename invalidparam: unsupported parameter type int
// ERROR: //go:wasmimport modulename invalidparam: unsupported parameter type string
//go:wasmimport modulename validparam
func validparam(a int32, b uint64, c float64, d unsafe.Pointer, e Uint, f uintptr, g string, h *int32, i *S)
// ERROR: //go:wasmimport modulename invalidparam: unsupported parameter type [4]uint32
// ERROR: //go:wasmimport modulename invalidparam: unsupported parameter type []byte
// ERROR: //go:wasmimport modulename invalidparam: unsupported parameter type *int32
// ERROR: //go:wasmimport modulename invalidparam: unsupported parameter type struct{a int}
// ERROR: //go:wasmimport modulename invalidparam: unsupported parameter type chan struct{}
// ERROR: //go:wasmimport modulename invalidparam: unsupported parameter type func()
//
//go:wasmimport modulename invalidparam
func invalidparam(a int, b string, c []byte, d *int32)
func invalidparam(a [4]uint32, b []byte, c struct{ a int }, d chan struct{}, e func())
//go:wasmimport modulename validreturn
func validreturn() int32
//go:wasmimport modulename validreturn_int32
func validreturn_int32() int32
//go:wasmimport modulename validreturn_int
func validreturn_int() int
//go:wasmimport modulename validreturn_ptr_int32
func validreturn_ptr_int32() *int32
//go:wasmimport modulename validreturn_ptr_string
func validreturn_ptr_string() *string
//go:wasmimport modulename validreturn_ptr_struct
func validreturn_ptr_struct() *S
//go:wasmimport modulename validreturn_unsafe_pointer
func validreturn_unsafe_pointer() unsafe.Pointer
// ERROR: //go:wasmimport modulename manyreturns: too many return values
//
//go:wasmimport modulename manyreturns
func manyreturns() (int32, int32)
// ERROR: //go:wasmimport modulename invalidreturn: unsupported result type int
// ERROR: //go:wasmimport modulename invalidreturn_func: unsupported result type func()
//
//go:wasmimport modulename invalidreturn
func invalidreturn() int
//go:wasmimport modulename invalidreturn_func
func invalidreturn_func() func()
// ERROR: //go:wasmimport modulename invalidUnsafePointerReturn: unsupported result type unsafe.Pointer
// ERROR: //go:wasmimport modulename invalidreturn_slice_byte: unsupported result type []byte
//
//go:wasmimport modulename invalidUnsafePointerReturn
func invalidUnsafePointerReturn() unsafe.Pointer
//go:wasmimport modulename invalidreturn_slice_byte
func invalidreturn_slice_byte() []byte
// ERROR: //go:wasmimport modulename invalidreturn_chan_int: unsupported result type chan int
//
//go:wasmimport modulename invalidreturn_chan_int
func invalidreturn_chan_int() chan int
// ERROR: //go:wasmimport modulename invalidreturn_string: unsupported result type string
//
//go:wasmimport modulename invalidreturn_string
func invalidreturn_string() string
goenv/goenv.go
+5
View File
@@ -159,6 +159,11 @@ func Get(name string) string {
}
return findWasmOpt()
case "WASMTOOLS":
if path := os.Getenv("WASMTOOLS"); path != "" {
return path
}
return "wasm-tools"
default:
return ""
}
lib/wasi-cli
Submodule
+1
Submodule lib/wasi-cli added at 6ae8261709
loader/goroot.go
+3
View File
@@ -241,6 +241,7 @@ func pathsToOverride(goMinor int, needsSyscallPackage bool) map[string]bool {
"internal/fuzz/": false,
"internal/reflectlite/": false,
"internal/task/": false,
"internal/wasi/": false,
"machine/": false,
"net/": true,
"net/http/": false,
@@ -250,6 +251,8 @@ func pathsToOverride(goMinor int, needsSyscallPackage bool) map[string]bool {
"runtime/": false,
"sync/": true,
"testing/": true,
"vendor/": true,
"vendor/github.com/": false,
}
if goMinor >= 19 {
main.go
+60 -10
View File
@@ -306,16 +306,25 @@ func Test(pkgName string, stdout, stderr io.Writer, options *compileopts.Options
// reads any files.
//
// Ex. run --dir=.. --dir=../.. --dir=../../..
dirs := dirsToModuleRoot(result.MainDir, result.ModuleRoot)
var dirs []string
switch config.Options.Target {
case "wasip1":
dirs = dirsToModuleRootRel(result.MainDir, result.ModuleRoot)
case "wasip2":
dirs = dirsToModuleRootAbs(result.MainDir, result.ModuleRoot)
default:
return fmt.Errorf("unknown GOOS target: %v", config.Options.Target)
}
args := []string{"run"}
for _, d := range dirs[1:] {
for _, d := range dirs {
args = append(args, "--dir="+d)
}
// The below re-organizes the arguments so that the current
// directory is added last.
args = append(args, "--env=PWD="+cmd.Dir)
args = append(args, cmd.Args[1:]...)
cmd.Args = append(cmd.Args[:1:1], args...)
cmd.Args = args
}
// Run the test.
@@ -356,8 +365,8 @@ func Test(pkgName string, stdout, stderr io.Writer, options *compileopts.Options
return passed, err
}
func dirsToModuleRoot(maindir, modroot string) []string {
var dirs = []string{"."}
func dirsToModuleRootRel(maindir, modroot string) []string {
var dirs []string
last := ".."
// strip off path elements until we hit the module root
// adding `..`, `../..`, `../../..` until we're done
@@ -366,6 +375,20 @@ func dirsToModuleRoot(maindir, modroot string) []string {
last = filepath.Join(last, "..")
maindir = filepath.Dir(maindir)
}
dirs = append(dirs, ".")
return dirs
}
func dirsToModuleRootAbs(maindir, modroot string) []string {
var dirs = []string{maindir}
last := filepath.Join(maindir, "..")
// strip off path elements until we hit the module root
// adding `..`, `../..`, `../../..` until we're done
for maindir != modroot {
dirs = append(dirs, last)
last = filepath.Join(last, "..")
maindir = filepath.Dir(maindir)
}
return dirs
}
@@ -785,6 +808,9 @@ func Run(pkgName string, options *compileopts.Options, cmdArgs []string) error {
// passes command line arguments and evironment variables in a way appropriate
// for the given emulator.
func buildAndRun(pkgName string, config *compileopts.Config, stdout io.Writer, cmdArgs, environmentVars []string, timeout time.Duration, run func(cmd *exec.Cmd, result builder.BuildResult) error) (builder.BuildResult, error) {
isSingleFile := strings.HasSuffix(pkgName, ".go")
// Determine whether we're on a system that supports environment variables
// and command line parameters (operating systems, WASI) or not (baremetal,
// WebAssembly in the browser). If we're on a system without an environment,
@@ -818,9 +844,6 @@ func buildAndRun(pkgName string, config *compileopts.Config, stdout io.Writer, c
}
}
} else if config.EmulatorName() == "wasmtime" {
// Wasmtime needs some special flags to pass environment variables
// and allow reading from the current directory.
emuArgs = append(emuArgs, "--dir=.")
for _, v := range environmentVars {
emuArgs = append(emuArgs, "--env", v)
}
@@ -876,7 +899,26 @@ func buildAndRun(pkgName string, config *compileopts.Config, stdout io.Writer, c
if err != nil {
return result, err
}
name = emulator[0]
if name == "wasmtime" {
// Wasmtime needs some special flags to pass environment variables
// and allow reading from the current directory.
switch config.Options.Target {
case "wasip1":
emuArgs = append(emuArgs, "--dir=.")
case "wasip2":
dir := result.MainDir
if isSingleFile {
cwd, _ := os.Getwd()
dir = cwd
}
emuArgs = append(emuArgs, "--dir="+dir)
emuArgs = append(emuArgs, "--env=PWD="+dir)
}
}
emuArgs = append(emuArgs, emulator[1:]...)
args = append(emuArgs, args...)
}
@@ -1465,6 +1507,12 @@ func main() {
flag.StringVar(&outpath, "o", "", "output filename")
}
var witPackage, witWorld string
if command == "help" || command == "build" || command == "test" || command == "run" {
flag.StringVar(&witPackage, "wit-package", "", "wit package for wasm component embedding")
flag.StringVar(&witWorld, "wit-world", "", "wit world for wasm component embedding")
}
var testConfig compileopts.TestConfig
if command == "help" || command == "test" {
flag.BoolVar(&testConfig.CompileOnly, "c", false, "compile the test binary but do not run it")
@@ -1544,6 +1592,8 @@ func main() {
Monitor: *monitor,
BaudRate: *baudrate,
Timeout: *timeout,
WITPackage: witPackage,
WITWorld: witWorld,
}
if *printCommands {
options.PrintCommands = printCommand
main_test.go
+12
View File
@@ -181,6 +181,10 @@ func TestBuild(t *testing.T) {
t.Parallel()
runPlatTests(optionsFromTarget("wasip1", sema), tests, t)
})
t.Run("WASIp2", func(t *testing.T) {
t.Parallel()
runPlatTests(optionsFromTarget("wasip2", sema), tests, t)
})
}
}
@@ -235,6 +239,14 @@ func runPlatTests(options compileopts.Options, tests []string, t *testing.T) {
default:
}
}
if options.Target == "wasip2" {
switch name {
case "cgo/":
// waisp2 use our own libc; cgo tests fail
continue
}
}
name := name // redefine to avoid race condition
t.Run(name, func(t *testing.T) {
t.Parallel()
src/crypto/rand/rand_arc4random.go
+1 -1
View File
@@ -1,4 +1,4 @@
//go:build darwin || tinygo.wasm
//go:build darwin || wasip1 || wasip2 || wasm
// This implementation of crypto/rand uses the arc4random_buf function
// (available on both MacOS and WASI) to generate random numbers.
src/crypto/rand/rand_urandom.go
+1 -1
View File
@@ -1,4 +1,4 @@
//go:build linux && !baremetal && !wasip1
//go:build linux && !baremetal && !wasip1 && !wasip2
// This implementation of crypto/rand uses the /dev/urandom pseudo-file to
// generate random numbers.
src/internal/wasi/cli/v0.2.0/command/command.wit.go
+6
View File
@@ -0,0 +1,6 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package command represents the world "wasi:cli/command@0.2.0".
package command
src/internal/wasi/cli/v0.2.0/environment/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/cli/v0.2.0/environment/environment.wit.go
+66
View File
@@ -0,0 +1,66 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package environment represents the imported interface "wasi:cli/environment@0.2.0".
package environment
import (
"github.com/ydnar/wasm-tools-go/cm"
)
// GetEnvironment represents the imported function "get-environment".
//
// 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.
//
// get-environment: func() -> list<tuple<string, string>>
//
//go:nosplit
func GetEnvironment() (result cm.List[[2]string]) {
wasmimport_GetEnvironment(&result)
return
}
//go:wasmimport wasi:cli/environment@0.2.0 get-environment
//go:noescape
func wasmimport_GetEnvironment(result *cm.List[[2]string])
// GetArguments represents the imported function "get-arguments".
//
// Get the POSIX-style arguments to the program.
//
// get-arguments: func() -> list<string>
//
//go:nosplit
func GetArguments() (result cm.List[string]) {
wasmimport_GetArguments(&result)
return
}
//go:wasmimport wasi:cli/environment@0.2.0 get-arguments
//go:noescape
func wasmimport_GetArguments(result *cm.List[string])
// InitialCWD represents the imported function "initial-cwd".
//
// Return a path that programs should use as their initial current working
// directory, interpreting `.` as shorthand for this.
//
// initial-cwd: func() -> option<string>
//
//go:nosplit
func InitialCWD() (result cm.Option[string]) {
wasmimport_InitialCWD(&result)
return
}
//go:wasmimport wasi:cli/environment@0.2.0 initial-cwd
//go:noescape
func wasmimport_InitialCWD(result *cm.Option[string])
src/internal/wasi/cli/v0.2.0/exit/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/cli/v0.2.0/exit/exit.wit.go
+27
View File
@@ -0,0 +1,27 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package exit represents the imported interface "wasi:cli/exit@0.2.0".
package exit
import (
"github.com/ydnar/wasm-tools-go/cm"
)
// Exit represents the imported function "exit".
//
// Exit the current instance and any linked instances.
//
// exit: func(status: result)
//
//go:nosplit
func Exit(status cm.Result) {
status0 := cm.LowerResult(status)
wasmimport_Exit((uint32)(status0))
return
}
//go:wasmimport wasi:cli/exit@0.2.0 exit
//go:noescape
func wasmimport_Exit(status0 uint32)
src/internal/wasi/cli/v0.2.0/run/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/cli/v0.2.0/run/run.exports.go
+19
View File
@@ -0,0 +1,19 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
package run
import (
"github.com/ydnar/wasm-tools-go/cm"
)
// Exports represents the caller-defined exports from "wasi:cli/run@0.2.0".
var Exports struct {
// Run represents the caller-defined, exported function "run".
//
// Run the program.
//
// run: func() -> result
Run func() (result cm.Result)
}
src/internal/wasi/cli/v0.2.0/run/run.wit.go
+18
View File
@@ -0,0 +1,18 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package run represents the exported interface "wasi:cli/run@0.2.0".
package run
import (
"github.com/ydnar/wasm-tools-go/cm"
)
//go:wasmexport wasi:cli/run@0.2.0#run
//export wasi:cli/run@0.2.0#run
func wasmexport_Run() (result0 uint32) {
result := Exports.Run()
result0 = cm.LowerResult(result)
return
}
src/internal/wasi/cli/v0.2.0/stderr/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/cli/v0.2.0/stderr/stderr.wit.go
+26
View File
@@ -0,0 +1,26 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package stderr represents the imported interface "wasi:cli/stderr@0.2.0".
package stderr
import (
"github.com/ydnar/wasm-tools-go/cm"
"internal/wasi/io/v0.2.0/streams"
)
// GetStderr represents the imported function "get-stderr".
//
// get-stderr: func() -> output-stream
//
//go:nosplit
func GetStderr() (result streams.OutputStream) {
result0 := wasmimport_GetStderr()
result = cm.Reinterpret[streams.OutputStream]((uint32)(result0))
return
}
//go:wasmimport wasi:cli/stderr@0.2.0 get-stderr
//go:noescape
func wasmimport_GetStderr() (result0 uint32)
src/internal/wasi/cli/v0.2.0/stdin/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/cli/v0.2.0/stdin/stdin.wit.go
+26
View File
@@ -0,0 +1,26 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package stdin represents the imported interface "wasi:cli/stdin@0.2.0".
package stdin
import (
"github.com/ydnar/wasm-tools-go/cm"
"internal/wasi/io/v0.2.0/streams"
)
// GetStdin represents the imported function "get-stdin".
//
// get-stdin: func() -> input-stream
//
//go:nosplit
func GetStdin() (result streams.InputStream) {
result0 := wasmimport_GetStdin()
result = cm.Reinterpret[streams.InputStream]((uint32)(result0))
return
}
//go:wasmimport wasi:cli/stdin@0.2.0 get-stdin
//go:noescape
func wasmimport_GetStdin() (result0 uint32)
src/internal/wasi/cli/v0.2.0/stdout/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/cli/v0.2.0/stdout/stdout.wit.go
+26
View File
@@ -0,0 +1,26 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package stdout represents the imported interface "wasi:cli/stdout@0.2.0".
package stdout
import (
"github.com/ydnar/wasm-tools-go/cm"
"internal/wasi/io/v0.2.0/streams"
)
// GetStdout represents the imported function "get-stdout".
//
// get-stdout: func() -> output-stream
//
//go:nosplit
func GetStdout() (result streams.OutputStream) {
result0 := wasmimport_GetStdout()
result = cm.Reinterpret[streams.OutputStream]((uint32)(result0))
return
}
//go:wasmimport wasi:cli/stdout@0.2.0 get-stdout
//go:noescape
func wasmimport_GetStdout() (result0 uint32)
src/internal/wasi/cli/v0.2.0/terminal-input/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/cli/v0.2.0/terminal-input/terminal-input.wit.go
+38
View File
@@ -0,0 +1,38 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package terminalinput represents the imported interface "wasi:cli/terminal-input@0.2.0".
//
// Terminal input.
//
// In the future, this may include functions for disabling echoing,
// disabling input buffering so that keyboard events are sent through
// immediately, querying supported features, and so on.
package terminalinput
import (
"github.com/ydnar/wasm-tools-go/cm"
)
// TerminalInput represents the imported resource "wasi:cli/terminal-input@0.2.0#terminal-input".
//
// The input side of a terminal.
//
// resource terminal-input
type TerminalInput cm.Resource
// ResourceDrop represents the imported resource-drop for resource "terminal-input".
//
// Drops a resource handle.
//
//go:nosplit
func (self TerminalInput) ResourceDrop() {
self0 := cm.Reinterpret[uint32](self)
wasmimport_TerminalInputResourceDrop((uint32)(self0))
return
}
//go:wasmimport wasi:cli/terminal-input@0.2.0 [resource-drop]terminal-input
//go:noescape
func wasmimport_TerminalInputResourceDrop(self0 uint32)
src/internal/wasi/cli/v0.2.0/terminal-output/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/cli/v0.2.0/terminal-output/terminal-output.wit.go
+38
View File
@@ -0,0 +1,38 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package terminaloutput represents the imported interface "wasi:cli/terminal-output@0.2.0".
//
// Terminal output.
//
// In the future, this may include functions for querying the terminal
// size, being notified of terminal size changes, querying supported
// features, and so on.
package terminaloutput
import (
"github.com/ydnar/wasm-tools-go/cm"
)
// TerminalOutput represents the imported resource "wasi:cli/terminal-output@0.2.0#terminal-output".
//
// The output side of a terminal.
//
// resource terminal-output
type TerminalOutput cm.Resource
// ResourceDrop represents the imported resource-drop for resource "terminal-output".
//
// Drops a resource handle.
//
//go:nosplit
func (self TerminalOutput) ResourceDrop() {
self0 := cm.Reinterpret[uint32](self)
wasmimport_TerminalOutputResourceDrop((uint32)(self0))
return
}
//go:wasmimport wasi:cli/terminal-output@0.2.0 [resource-drop]terminal-output
//go:noescape
func wasmimport_TerminalOutputResourceDrop(self0 uint32)
src/internal/wasi/cli/v0.2.0/terminal-stderr/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/cli/v0.2.0/terminal-stderr/terminal-stderr.wit.go
+31
View File
@@ -0,0 +1,31 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package terminalstderr represents the imported interface "wasi:cli/terminal-stderr@0.2.0".
//
// An interface providing an optional `terminal-output` for stderr as a
// link-time authority.
package terminalstderr
import (
"github.com/ydnar/wasm-tools-go/cm"
terminaloutput "internal/wasi/cli/v0.2.0/terminal-output"
)
// GetTerminalStderr represents the imported function "get-terminal-stderr".
//
// If stderr is connected to a terminal, return a `terminal-output` handle
// allowing further interaction with it.
//
// get-terminal-stderr: func() -> option<terminal-output>
//
//go:nosplit
func GetTerminalStderr() (result cm.Option[terminaloutput.TerminalOutput]) {
wasmimport_GetTerminalStderr(&result)
return
}
//go:wasmimport wasi:cli/terminal-stderr@0.2.0 get-terminal-stderr
//go:noescape
func wasmimport_GetTerminalStderr(result *cm.Option[terminaloutput.TerminalOutput])
src/internal/wasi/cli/v0.2.0/terminal-stdin/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/cli/v0.2.0/terminal-stdin/terminal-stdin.wit.go
+31
View File
@@ -0,0 +1,31 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package terminalstdin represents the imported interface "wasi:cli/terminal-stdin@0.2.0".
//
// An interface providing an optional `terminal-input` for stdin as a
// link-time authority.
package terminalstdin
import (
"github.com/ydnar/wasm-tools-go/cm"
terminalinput "internal/wasi/cli/v0.2.0/terminal-input"
)
// GetTerminalStdin represents the imported function "get-terminal-stdin".
//
// If stdin is connected to a terminal, return a `terminal-input` handle
// allowing further interaction with it.
//
// get-terminal-stdin: func() -> option<terminal-input>
//
//go:nosplit
func GetTerminalStdin() (result cm.Option[terminalinput.TerminalInput]) {
wasmimport_GetTerminalStdin(&result)
return
}
//go:wasmimport wasi:cli/terminal-stdin@0.2.0 get-terminal-stdin
//go:noescape
func wasmimport_GetTerminalStdin(result *cm.Option[terminalinput.TerminalInput])
src/internal/wasi/cli/v0.2.0/terminal-stdout/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/cli/v0.2.0/terminal-stdout/terminal-stdout.wit.go
+31
View File
@@ -0,0 +1,31 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package terminalstdout represents the imported interface "wasi:cli/terminal-stdout@0.2.0".
//
// An interface providing an optional `terminal-output` for stdout as a
// link-time authority.
package terminalstdout
import (
"github.com/ydnar/wasm-tools-go/cm"
terminaloutput "internal/wasi/cli/v0.2.0/terminal-output"
)
// GetTerminalStdout represents the imported function "get-terminal-stdout".
//
// If stdout is connected to a terminal, return a `terminal-output` handle
// allowing further interaction with it.
//
// get-terminal-stdout: func() -> option<terminal-output>
//
//go:nosplit
func GetTerminalStdout() (result cm.Option[terminaloutput.TerminalOutput]) {
wasmimport_GetTerminalStdout(&result)
return
}
//go:wasmimport wasi:cli/terminal-stdout@0.2.0 get-terminal-stdout
//go:noescape
func wasmimport_GetTerminalStdout(result *cm.Option[terminaloutput.TerminalOutput])
src/internal/wasi/clocks/v0.2.0/monotonic-clock/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/clocks/v0.2.0/monotonic-clock/monotonic-clock.wit.go
+115
View File
@@ -0,0 +1,115 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package monotonicclock represents the imported interface "wasi:clocks/monotonic-clock@0.2.0".
//
// WASI Monotonic Clock is a clock API intended to let users measure elapsed
// time.
//
// It is intended to be portable at least between Unix-family platforms and
// Windows.
//
// A monotonic clock is a clock which has an unspecified initial value, and
// successive reads of the clock will produce non-decreasing values.
//
// It is intended for measuring elapsed time.
package monotonicclock
import (
"github.com/ydnar/wasm-tools-go/cm"
"internal/wasi/io/v0.2.0/poll"
)
// Instant represents the u64 "wasi:clocks/monotonic-clock@0.2.0#instant".
//
// 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.
//
// type instant = u64
type Instant uint64
// Duration represents the u64 "wasi:clocks/monotonic-clock@0.2.0#duration".
//
// A duration of time, in nanoseconds.
//
// type duration = u64
type Duration uint64
// Now represents the imported function "now".
//
// Read the current value of the clock.
//
// The clock is monotonic, therefore calling this function repeatedly will
// produce a sequence of non-decreasing values.
//
// now: func() -> instant
//
//go:nosplit
func Now() (result Instant) {
result0 := wasmimport_Now()
result = (Instant)((uint64)(result0))
return
}
//go:wasmimport wasi:clocks/monotonic-clock@0.2.0 now
//go:noescape
func wasmimport_Now() (result0 uint64)
// Resolution represents the imported function "resolution".
//
// Query the resolution of the clock. Returns the duration of time
// corresponding to a clock tick.
//
// resolution: func() -> duration
//
//go:nosplit
func Resolution() (result Duration) {
result0 := wasmimport_Resolution()
result = (Duration)((uint64)(result0))
return
}
//go:wasmimport wasi:clocks/monotonic-clock@0.2.0 resolution
//go:noescape
func wasmimport_Resolution() (result0 uint64)
// SubscribeInstant represents the imported function "subscribe-instant".
//
// Create a `pollable` which will resolve once the specified instant
// occured.
//
// subscribe-instant: func(when: instant) -> pollable
//
//go:nosplit
func SubscribeInstant(when Instant) (result poll.Pollable) {
when0 := (uint64)(when)
result0 := wasmimport_SubscribeInstant((uint64)(when0))
result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
return
}
//go:wasmimport wasi:clocks/monotonic-clock@0.2.0 subscribe-instant
//go:noescape
func wasmimport_SubscribeInstant(when0 uint64) (result0 uint32)
// SubscribeDuration represents the imported function "subscribe-duration".
//
// Create a `pollable` which will resolve once the given duration has
// elapsed, starting at the time at which this function was called.
// occured.
//
// subscribe-duration: func(when: duration) -> pollable
//
//go:nosplit
func SubscribeDuration(when Duration) (result poll.Pollable) {
when0 := (uint64)(when)
result0 := wasmimport_SubscribeDuration((uint64)(when0))
result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
return
}
//go:wasmimport wasi:clocks/monotonic-clock@0.2.0 subscribe-duration
//go:noescape
func wasmimport_SubscribeDuration(when0 uint64) (result0 uint32)
src/internal/wasi/clocks/v0.2.0/wall-clock/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/clocks/v0.2.0/wall-clock/wall-clock.wit.go
+80
View File
@@ -0,0 +1,80 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package wallclock represents the imported interface "wasi:clocks/wall-clock@0.2.0".
//
// WASI Wall Clock is a clock API intended to let users query the current
// time. The name "wall" makes an analogy to a "clock on the wall", which
// is not necessarily monotonic as it may be reset.
//
// It is intended to be portable at least between Unix-family platforms and
// Windows.
//
// A wall clock is a clock which measures the date and time according to
// some external reference.
//
// External references may be reset, so this clock is not necessarily
// monotonic, making it unsuitable for measuring elapsed time.
//
// It is intended for reporting the current date and time for humans.
package wallclock
// DateTime represents the record "wasi:clocks/wall-clock@0.2.0#datetime".
//
// A time and date in seconds plus nanoseconds.
//
// record datetime {
// seconds: u64,
// nanoseconds: u32,
// }
type DateTime struct {
Seconds uint64
Nanoseconds uint32
}
// Now represents the imported function "now".
//
// 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.
//
// now: func() -> datetime
//
// [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
//
//go:nosplit
func Now() (result DateTime) {
wasmimport_Now(&result)
return
}
//go:wasmimport wasi:clocks/wall-clock@0.2.0 now
//go:noescape
func wasmimport_Now(result *DateTime)
// Resolution represents the imported function "resolution".
//
// Query the resolution of the clock.
//
// The nanoseconds field of the output is always less than 1000000000.
//
// resolution: func() -> datetime
//
//go:nosplit
func Resolution() (result DateTime) {
wasmimport_Resolution(&result)
return
}
//go:wasmimport wasi:clocks/wall-clock@0.2.0 resolution
//go:noescape
func wasmimport_Resolution(result *DateTime)
src/internal/wasi/filesystem/v0.2.0/preopens/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/filesystem/v0.2.0/preopens/preopens.wit.go
+27
View File
@@ -0,0 +1,27 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package preopens represents the imported interface "wasi:filesystem/preopens@0.2.0".
package preopens
import (
"github.com/ydnar/wasm-tools-go/cm"
"internal/wasi/filesystem/v0.2.0/types"
)
// GetDirectories represents the imported function "get-directories".
//
// Return the set of preopened directories, and their path.
//
// get-directories: func() -> list<tuple<descriptor, string>>
//
//go:nosplit
func GetDirectories() (result cm.List[cm.Tuple[types.Descriptor, string]]) {
wasmimport_GetDirectories(&result)
return
}
//go:wasmimport wasi:filesystem/preopens@0.2.0 get-directories
//go:noescape
func wasmimport_GetDirectories(result *cm.List[cm.Tuple[types.Descriptor, string]])
src/internal/wasi/filesystem/v0.2.0/types/abi.go
+27
View File
@@ -0,0 +1,27 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
package types
import (
"github.com/ydnar/wasm-tools-go/cm"
wallclock "internal/wasi/clocks/v0.2.0/wall-clock"
)
func lower_DateTime(v wallclock.DateTime) (f0 uint64, f1 uint32) {
f0 = (uint64)(v.Seconds)
f1 = (uint32)(v.Nanoseconds)
return
}
func lower_NewTimestamp(v NewTimestamp) (f0 uint32, f1 uint64, f2 uint32) {
f0 = (uint32)(cm.Tag(&v))
switch f0 {
case 2: // timestamp
v1, v2 := lower_DateTime(*v.Timestamp())
f1 = (uint64)(v1)
f2 = (uint32)(v2)
}
return
}
src/internal/wasi/filesystem/v0.2.0/types/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/filesystem/v0.2.0/types/types.wit.go
+1284
View File
File diff suppressed because it is too large Load Diff
src/internal/wasi/io/v0.2.0/error/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/io/v0.2.0/error/error.wit.go
+73
View File
@@ -0,0 +1,73 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package ioerror represents the imported interface "wasi:io/error@0.2.0".
package ioerror
import (
"github.com/ydnar/wasm-tools-go/cm"
)
// Error represents the imported resource "wasi:io/error@0.2.0#error".
//
// A resource which represents some error information.
//
// The only method provided by this resource is `to-debug-string`,
// which provides some human-readable information about the error.
//
// In the `wasi:io` package, this resource is returned through the
// `wasi:io/streams/stream-error` type.
//
// To provide more specific error information, other interfaces may
// provide functions to further "downcast" this error into more specific
// error information. For example, `error`s returned in streams derived
// from filesystem types to be described using the filesystem's own
// error-code type, using the function
// `wasi:filesystem/types/filesystem-error-code`, which takes a parameter
// `borrow<error>` and returns
// `option<wasi:filesystem/types/error-code>`.
//
// The set of functions which can "downcast" an `error` into a more
// concrete type is open.
//
// resource error
type Error cm.Resource
// ResourceDrop represents the imported resource-drop for resource "error".
//
// Drops a resource handle.
//
//go:nosplit
func (self Error) ResourceDrop() {
self0 := cm.Reinterpret[uint32](self)
wasmimport_ErrorResourceDrop((uint32)(self0))
return
}
//go:wasmimport wasi:io/error@0.2.0 [resource-drop]error
//go:noescape
func wasmimport_ErrorResourceDrop(self0 uint32)
// ToDebugString represents the imported method "to-debug-string".
//
// 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.
//
// to-debug-string: func() -> string
//
//go:nosplit
func (self Error) ToDebugString() (result string) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_ErrorToDebugString((uint32)(self0), &result)
return
}
//go:wasmimport wasi:io/error@0.2.0 [method]error.to-debug-string
//go:noescape
func wasmimport_ErrorToDebugString(self0 uint32, result *string)
src/internal/wasi/io/v0.2.0/poll/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/io/v0.2.0/poll/poll.wit.go
+110
View File
@@ -0,0 +1,110 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package poll represents the imported interface "wasi:io/poll@0.2.0".
//
// A poll API intended to let users wait for I/O events on multiple handles
// at once.
package poll
import (
"github.com/ydnar/wasm-tools-go/cm"
)
// Pollable represents the imported resource "wasi:io/poll@0.2.0#pollable".
//
// `pollable` represents a single I/O event which may be ready, or not.
//
// resource pollable
type Pollable cm.Resource
// ResourceDrop represents the imported resource-drop for resource "pollable".
//
// Drops a resource handle.
//
//go:nosplit
func (self Pollable) ResourceDrop() {
self0 := cm.Reinterpret[uint32](self)
wasmimport_PollableResourceDrop((uint32)(self0))
return
}
//go:wasmimport wasi:io/poll@0.2.0 [resource-drop]pollable
//go:noescape
func wasmimport_PollableResourceDrop(self0 uint32)
// Block represents the imported method "block".
//
// `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.
//
// block: func()
//
//go:nosplit
func (self Pollable) Block() {
self0 := cm.Reinterpret[uint32](self)
wasmimport_PollableBlock((uint32)(self0))
return
}
//go:wasmimport wasi:io/poll@0.2.0 [method]pollable.block
//go:noescape
func wasmimport_PollableBlock(self0 uint32)
// Ready represents the imported method "ready".
//
// Return the readiness of a pollable. This function never blocks.
//
// Returns `true` when the pollable is ready, and `false` otherwise.
//
// ready: func() -> bool
//
//go:nosplit
func (self Pollable) Ready() (result bool) {
self0 := cm.Reinterpret[uint32](self)
result0 := wasmimport_PollableReady((uint32)(self0))
result = cm.U32ToBool((uint32)(result0))
return
}
//go:wasmimport wasi:io/poll@0.2.0 [method]pollable.ready
//go:noescape
func wasmimport_PollableReady(self0 uint32) (result0 uint32)
// Poll represents the imported function "poll".
//
// 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.
//
// poll: func(in: list<borrow<pollable>>) -> list<u32>
//
//go:nosplit
func Poll(in cm.List[Pollable]) (result cm.List[uint32]) {
in0, in1 := cm.LowerList(in)
wasmimport_Poll((*Pollable)(in0), (uint32)(in1), &result)
return
}
//go:wasmimport wasi:io/poll@0.2.0 poll
//go:noescape
func wasmimport_Poll(in0 *Pollable, in1 uint32, result *cm.List[uint32])
src/internal/wasi/io/v0.2.0/streams/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/io/v0.2.0/streams/streams.wit.go
+521
View File
@@ -0,0 +1,521 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package streams represents the imported interface "wasi:io/streams@0.2.0".
//
// WASI I/O is an I/O abstraction API which is currently focused on providing
// stream types.
//
// In the future, the component model is expected to add built-in stream types;
// when it does, they are expected to subsume this API.
package streams
import (
"github.com/ydnar/wasm-tools-go/cm"
ioerror "internal/wasi/io/v0.2.0/error"
"internal/wasi/io/v0.2.0/poll"
)
// StreamError represents the imported variant "wasi:io/streams@0.2.0#stream-error".
//
// An error for input-stream and output-stream operations.
//
// variant stream-error {
// last-operation-failed(error),
// closed,
// }
type StreamError cm.Variant[uint8, ioerror.Error, ioerror.Error]
// StreamErrorLastOperationFailed returns a [StreamError] of case "last-operation-failed".
//
// The last operation (a write or flush) failed before completion.
//
// More information is available in the `error` payload.
func StreamErrorLastOperationFailed(data ioerror.Error) StreamError {
return cm.New[StreamError](0, data)
}
// LastOperationFailed returns a non-nil *[ioerror.Error] if [StreamError] represents the variant case "last-operation-failed".
func (self *StreamError) LastOperationFailed() *ioerror.Error {
return cm.Case[ioerror.Error](self, 0)
}
// StreamErrorClosed returns a [StreamError] of case "closed".
//
// 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.
func StreamErrorClosed() StreamError {
var data struct{}
return cm.New[StreamError](1, data)
}
// Closed returns true if [StreamError] represents the variant case "closed".
func (self *StreamError) Closed() bool {
return cm.Tag(self) == 1
}
// InputStream represents the imported resource "wasi:io/streams@0.2.0#input-stream".
//
// An input bytestream.
//
// `input-stream`s are *non-blocking* to the extent practical on underlying
// platforms. I/O operations always return promptly; if fewer bytes are
// promptly available than requested, they return the number of bytes promptly
// available, which could even be zero. To wait for data to be available,
// use the `subscribe` function to obtain a `pollable` which can be polled
// for using `wasi:io/poll`.
//
// resource input-stream
type InputStream cm.Resource
// ResourceDrop represents the imported resource-drop for resource "input-stream".
//
// Drops a resource handle.
//
//go:nosplit
func (self InputStream) ResourceDrop() {
self0 := cm.Reinterpret[uint32](self)
wasmimport_InputStreamResourceDrop((uint32)(self0))
return
}
//go:wasmimport wasi:io/streams@0.2.0 [resource-drop]input-stream
//go:noescape
func wasmimport_InputStreamResourceDrop(self0 uint32)
// BlockingRead represents the imported method "blocking-read".
//
// Read bytes from a stream, after blocking until at least one byte can
// be read. Except for blocking, behavior is identical to `read`.
//
// blocking-read: func(len: u64) -> result<list<u8>, stream-error>
//
//go:nosplit
func (self InputStream) BlockingRead(len_ uint64) (result cm.OKResult[cm.List[uint8], StreamError]) {
self0 := cm.Reinterpret[uint32](self)
len0 := (uint64)(len_)
wasmimport_InputStreamBlockingRead((uint32)(self0), (uint64)(len0), &result)
return
}
//go:wasmimport wasi:io/streams@0.2.0 [method]input-stream.blocking-read
//go:noescape
func wasmimport_InputStreamBlockingRead(self0 uint32, len0 uint64, result *cm.OKResult[cm.List[uint8], StreamError])
// BlockingSkip represents the imported method "blocking-skip".
//
// Skip bytes from a stream, after blocking until at least one byte
// can be skipped. Except for blocking behavior, identical to `skip`.
//
// blocking-skip: func(len: u64) -> result<u64, stream-error>
//
//go:nosplit
func (self InputStream) BlockingSkip(len_ uint64) (result cm.OKResult[uint64, StreamError]) {
self0 := cm.Reinterpret[uint32](self)
len0 := (uint64)(len_)
wasmimport_InputStreamBlockingSkip((uint32)(self0), (uint64)(len0), &result)
return
}
//go:wasmimport wasi:io/streams@0.2.0 [method]input-stream.blocking-skip
//go:noescape
func wasmimport_InputStreamBlockingSkip(self0 uint32, len0 uint64, result *cm.OKResult[uint64, StreamError])
// Read represents the imported method "read".
//
// 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.
//
// read: func(len: u64) -> result<list<u8>, stream-error>
//
//go:nosplit
func (self InputStream) Read(len_ uint64) (result cm.OKResult[cm.List[uint8], StreamError]) {
self0 := cm.Reinterpret[uint32](self)
len0 := (uint64)(len_)
wasmimport_InputStreamRead((uint32)(self0), (uint64)(len0), &result)
return
}
//go:wasmimport wasi:io/streams@0.2.0 [method]input-stream.read
//go:noescape
func wasmimport_InputStreamRead(self0 uint32, len0 uint64, result *cm.OKResult[cm.List[uint8], StreamError])
// Skip represents the imported method "skip".
//
// 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.
//
// skip: func(len: u64) -> result<u64, stream-error>
//
//go:nosplit
func (self InputStream) Skip(len_ uint64) (result cm.OKResult[uint64, StreamError]) {
self0 := cm.Reinterpret[uint32](self)
len0 := (uint64)(len_)
wasmimport_InputStreamSkip((uint32)(self0), (uint64)(len0), &result)
return
}
//go:wasmimport wasi:io/streams@0.2.0 [method]input-stream.skip
//go:noescape
func wasmimport_InputStreamSkip(self0 uint32, len0 uint64, result *cm.OKResult[uint64, StreamError])
// Subscribe represents the imported method "subscribe".
//
// 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.
//
// subscribe: func() -> pollable
//
//go:nosplit
func (self InputStream) Subscribe() (result poll.Pollable) {
self0 := cm.Reinterpret[uint32](self)
result0 := wasmimport_InputStreamSubscribe((uint32)(self0))
result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
return
}
//go:wasmimport wasi:io/streams@0.2.0 [method]input-stream.subscribe
//go:noescape
func wasmimport_InputStreamSubscribe(self0 uint32) (result0 uint32)
// OutputStream represents the imported resource "wasi:io/streams@0.2.0#output-stream".
//
// An output bytestream.
//
// `output-stream`s are *non-blocking* to the extent practical on
// underlying platforms. Except where specified otherwise, I/O operations also
// always return promptly, after the number of bytes that can be written
// promptly, which could even be zero. To wait for the stream to be ready to
// accept data, the `subscribe` function to obtain a `pollable` which can be
// polled for using `wasi:io/poll`.
//
// resource output-stream
type OutputStream cm.Resource
// ResourceDrop represents the imported resource-drop for resource "output-stream".
//
// Drops a resource handle.
//
//go:nosplit
func (self OutputStream) ResourceDrop() {
self0 := cm.Reinterpret[uint32](self)
wasmimport_OutputStreamResourceDrop((uint32)(self0))
return
}
//go:wasmimport wasi:io/streams@0.2.0 [resource-drop]output-stream
//go:noescape
func wasmimport_OutputStreamResourceDrop(self0 uint32)
// BlockingFlush represents the imported method "blocking-flush".
//
// Request to flush buffered output, and block until flush completes
// and stream is ready for writing again.
//
// blocking-flush: func() -> result<_, stream-error>
//
//go:nosplit
func (self OutputStream) BlockingFlush() (result cm.ErrResult[struct{}, StreamError]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_OutputStreamBlockingFlush((uint32)(self0), &result)
return
}
//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.blocking-flush
//go:noescape
func wasmimport_OutputStreamBlockingFlush(self0 uint32, result *cm.ErrResult[struct{}, StreamError])
// BlockingSplice represents the imported method "blocking-splice".
//
// 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`.
//
// blocking-splice: func(src: borrow<input-stream>, len: u64) -> result<u64, stream-error>
//
//go:nosplit
func (self OutputStream) BlockingSplice(src InputStream, len_ uint64) (result cm.OKResult[uint64, StreamError]) {
self0 := cm.Reinterpret[uint32](self)
src0 := cm.Reinterpret[uint32](src)
len0 := (uint64)(len_)
wasmimport_OutputStreamBlockingSplice((uint32)(self0), (uint32)(src0), (uint64)(len0), &result)
return
}
//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.blocking-splice
//go:noescape
func wasmimport_OutputStreamBlockingSplice(self0 uint32, src0 uint32, len0 uint64, result *cm.OKResult[uint64, StreamError])
// BlockingWriteAndFlush represents the imported method "blocking-write-and-flush".
//
// 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:
//
// 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
//
// blocking-write-and-flush: func(contents: list<u8>) -> result<_, stream-error>
//
//go:nosplit
func (self OutputStream) BlockingWriteAndFlush(contents cm.List[uint8]) (result cm.ErrResult[struct{}, StreamError]) {
self0 := cm.Reinterpret[uint32](self)
contents0, contents1 := cm.LowerList(contents)
wasmimport_OutputStreamBlockingWriteAndFlush((uint32)(self0), (*uint8)(contents0), (uint32)(contents1), &result)
return
}
//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.blocking-write-and-flush
//go:noescape
func wasmimport_OutputStreamBlockingWriteAndFlush(self0 uint32, contents0 *uint8, contents1 uint32, result *cm.ErrResult[struct{}, StreamError])
// BlockingWriteZeroesAndFlush represents the imported method "blocking-write-zeroes-and-flush".
//
// 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:
//
// 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
//
// blocking-write-zeroes-and-flush: func(len: u64) -> result<_, stream-error>
//
//go:nosplit
func (self OutputStream) BlockingWriteZeroesAndFlush(len_ uint64) (result cm.ErrResult[struct{}, StreamError]) {
self0 := cm.Reinterpret[uint32](self)
len0 := (uint64)(len_)
wasmimport_OutputStreamBlockingWriteZeroesAndFlush((uint32)(self0), (uint64)(len0), &result)
return
}
//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.blocking-write-zeroes-and-flush
//go:noescape
func wasmimport_OutputStreamBlockingWriteZeroesAndFlush(self0 uint32, len0 uint64, result *cm.ErrResult[struct{}, StreamError])
// CheckWrite represents the imported method "check-write".
//
// 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.
//
// check-write: func() -> result<u64, stream-error>
//
//go:nosplit
func (self OutputStream) CheckWrite() (result cm.OKResult[uint64, StreamError]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_OutputStreamCheckWrite((uint32)(self0), &result)
return
}
//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.check-write
//go:noescape
func wasmimport_OutputStreamCheckWrite(self0 uint32, result *cm.OKResult[uint64, StreamError])
// Flush represents the imported method "flush".
//
// 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.
//
// flush: func() -> result<_, stream-error>
//
//go:nosplit
func (self OutputStream) Flush() (result cm.ErrResult[struct{}, StreamError]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_OutputStreamFlush((uint32)(self0), &result)
return
}
//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.flush
//go:noescape
func wasmimport_OutputStreamFlush(self0 uint32, result *cm.ErrResult[struct{}, StreamError])
// Splice represents the imported method "splice".
//
// 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`.
//
// splice: func(src: borrow<input-stream>, len: u64) -> result<u64, stream-error>
//
//go:nosplit
func (self OutputStream) Splice(src InputStream, len_ uint64) (result cm.OKResult[uint64, StreamError]) {
self0 := cm.Reinterpret[uint32](self)
src0 := cm.Reinterpret[uint32](src)
len0 := (uint64)(len_)
wasmimport_OutputStreamSplice((uint32)(self0), (uint32)(src0), (uint64)(len0), &result)
return
}
//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.splice
//go:noescape
func wasmimport_OutputStreamSplice(self0 uint32, src0 uint32, len0 uint64, result *cm.OKResult[uint64, StreamError])
// Subscribe represents the imported method "subscribe".
//
// 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.
//
// subscribe: func() -> pollable
//
//go:nosplit
func (self OutputStream) Subscribe() (result poll.Pollable) {
self0 := cm.Reinterpret[uint32](self)
result0 := wasmimport_OutputStreamSubscribe((uint32)(self0))
result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
return
}
//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.subscribe
//go:noescape
func wasmimport_OutputStreamSubscribe(self0 uint32) (result0 uint32)
// Write represents the imported method "write".
//
// 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.
//
// write: func(contents: list<u8>) -> result<_, stream-error>
//
//go:nosplit
func (self OutputStream) Write(contents cm.List[uint8]) (result cm.ErrResult[struct{}, StreamError]) {
self0 := cm.Reinterpret[uint32](self)
contents0, contents1 := cm.LowerList(contents)
wasmimport_OutputStreamWrite((uint32)(self0), (*uint8)(contents0), (uint32)(contents1), &result)
return
}
//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.write
//go:noescape
func wasmimport_OutputStreamWrite(self0 uint32, contents0 *uint8, contents1 uint32, result *cm.ErrResult[struct{}, StreamError])
// WriteZeroes represents the imported method "write-zeroes".
//
// 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.
//
// write-zeroes: func(len: u64) -> result<_, stream-error>
//
//go:nosplit
func (self OutputStream) WriteZeroes(len_ uint64) (result cm.ErrResult[struct{}, StreamError]) {
self0 := cm.Reinterpret[uint32](self)
len0 := (uint64)(len_)
wasmimport_OutputStreamWriteZeroes((uint32)(self0), (uint64)(len0), &result)
return
}
//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.write-zeroes
//go:noescape
func wasmimport_OutputStreamWriteZeroes(self0 uint32, len0 uint64, result *cm.ErrResult[struct{}, StreamError])
src/internal/wasi/random/v0.2.0/insecure-seed/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/random/v0.2.0/insecure-seed/insecure-seed.wit.go
+43
View File
@@ -0,0 +1,43 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package insecureseed represents the imported interface "wasi:random/insecure-seed@0.2.0".
//
// The insecure-seed interface for seeding hash-map DoS resistance.
//
// It is intended to be portable at least between Unix-family platforms and
// Windows.
package insecureseed
// InsecureSeed represents the imported function "insecure-seed".
//
// 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.
//
// insecure-seed: func() -> tuple<u64, u64>
//
//go:nosplit
func InsecureSeed() (result [2]uint64) {
wasmimport_InsecureSeed(&result)
return
}
//go:wasmimport wasi:random/insecure-seed@0.2.0 insecure-seed
//go:noescape
func wasmimport_InsecureSeed(result *[2]uint64)
src/internal/wasi/random/v0.2.0/insecure/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/random/v0.2.0/insecure/insecure.wit.go
+59
View File
@@ -0,0 +1,59 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package insecure represents the imported interface "wasi:random/insecure@0.2.0".
//
// The insecure interface for insecure pseudo-random numbers.
//
// It is intended to be portable at least between Unix-family platforms and
// Windows.
package insecure
import (
"github.com/ydnar/wasm-tools-go/cm"
)
// GetInsecureRandomBytes represents the imported function "get-insecure-random-bytes".
//
// 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.
//
// get-insecure-random-bytes: func(len: u64) -> list<u8>
//
//go:nosplit
func GetInsecureRandomBytes(len_ uint64) (result cm.List[uint8]) {
len0 := (uint64)(len_)
wasmimport_GetInsecureRandomBytes((uint64)(len0), &result)
return
}
//go:wasmimport wasi:random/insecure@0.2.0 get-insecure-random-bytes
//go:noescape
func wasmimport_GetInsecureRandomBytes(len0 uint64, result *cm.List[uint8])
// GetInsecureRandomU64 represents the imported function "get-insecure-random-u64".
//
// 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`.
//
// get-insecure-random-u64: func() -> u64
//
//go:nosplit
func GetInsecureRandomU64() (result uint64) {
result0 := wasmimport_GetInsecureRandomU64()
result = (uint64)((uint64)(result0))
return
}
//go:wasmimport wasi:random/insecure@0.2.0 get-insecure-random-u64
//go:noescape
func wasmimport_GetInsecureRandomU64() (result0 uint64)
src/internal/wasi/random/v0.2.0/random/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/random/v0.2.0/random/random.wit.go
+63
View File
@@ -0,0 +1,63 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package random represents the imported interface "wasi:random/random@0.2.0".
//
// WASI Random is a random data API.
//
// It is intended to be portable at least between Unix-family platforms and
// Windows.
package random
import (
"github.com/ydnar/wasm-tools-go/cm"
)
// GetRandomBytes represents the imported function "get-random-bytes".
//
// 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.
//
// get-random-bytes: func(len: u64) -> list<u8>
//
//go:nosplit
func GetRandomBytes(len_ uint64) (result cm.List[uint8]) {
len0 := (uint64)(len_)
wasmimport_GetRandomBytes((uint64)(len0), &result)
return
}
//go:wasmimport wasi:random/random@0.2.0 get-random-bytes
//go:noescape
func wasmimport_GetRandomBytes(len0 uint64, result *cm.List[uint8])
// GetRandomU64 represents the imported function "get-random-u64".
//
// 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`.
//
// get-random-u64: func() -> u64
//
//go:nosplit
func GetRandomU64() (result uint64) {
result0 := wasmimport_GetRandomU64()
result = (uint64)((uint64)(result0))
return
}
//go:wasmimport wasi:random/random@0.2.0 get-random-u64
//go:noescape
func wasmimport_GetRandomU64() (result0 uint64)
src/internal/wasi/sockets/v0.2.0/instance-network/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/sockets/v0.2.0/instance-network/instance-network.wit.go
+30
View File
@@ -0,0 +1,30 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package instancenetwork represents the imported interface "wasi:sockets/instance-network@0.2.0".
//
// This interface provides a value-export of the default network handle..
package instancenetwork
import (
"github.com/ydnar/wasm-tools-go/cm"
"internal/wasi/sockets/v0.2.0/network"
)
// InstanceNetwork represents the imported function "instance-network".
//
// Get a handle to the default network.
//
// instance-network: func() -> network
//
//go:nosplit
func InstanceNetwork() (result network.Network) {
result0 := wasmimport_InstanceNetwork()
result = cm.Reinterpret[network.Network]((uint32)(result0))
return
}
//go:wasmimport wasi:sockets/instance-network@0.2.0 instance-network
//go:noescape
func wasmimport_InstanceNetwork() (result0 uint32)
src/internal/wasi/sockets/v0.2.0/ip-name-lookup/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/sockets/v0.2.0/ip-name-lookup/ip-name-lookup.wit.go
+123
View File
@@ -0,0 +1,123 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package ipnamelookup represents the imported interface "wasi:sockets/ip-name-lookup@0.2.0".
package ipnamelookup
import (
"github.com/ydnar/wasm-tools-go/cm"
"internal/wasi/io/v0.2.0/poll"
"internal/wasi/sockets/v0.2.0/network"
)
// ResolveAddressStream represents the imported resource "wasi:sockets/ip-name-lookup@0.2.0#resolve-address-stream".
//
// resource resolve-address-stream
type ResolveAddressStream cm.Resource
// ResourceDrop represents the imported resource-drop for resource "resolve-address-stream".
//
// Drops a resource handle.
//
//go:nosplit
func (self ResolveAddressStream) ResourceDrop() {
self0 := cm.Reinterpret[uint32](self)
wasmimport_ResolveAddressStreamResourceDrop((uint32)(self0))
return
}
//go:wasmimport wasi:sockets/ip-name-lookup@0.2.0 [resource-drop]resolve-address-stream
//go:noescape
func wasmimport_ResolveAddressStreamResourceDrop(self0 uint32)
// ResolveNextAddress represents the imported method "resolve-next-address".
//
// 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)
//
// resolve-next-address: func() -> result<option<ip-address>, error-code>
//
//go:nosplit
func (self ResolveAddressStream) ResolveNextAddress() (result cm.OKResult[cm.Option[network.IPAddress], network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_ResolveAddressStreamResolveNextAddress((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/ip-name-lookup@0.2.0 [method]resolve-address-stream.resolve-next-address
//go:noescape
func wasmimport_ResolveAddressStreamResolveNextAddress(self0 uint32, result *cm.OKResult[cm.Option[network.IPAddress], network.ErrorCode])
// Subscribe represents the imported method "subscribe".
//
// 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.
//
// subscribe: func() -> pollable
//
//go:nosplit
func (self ResolveAddressStream) Subscribe() (result poll.Pollable) {
self0 := cm.Reinterpret[uint32](self)
result0 := wasmimport_ResolveAddressStreamSubscribe((uint32)(self0))
result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
return
}
//go:wasmimport wasi:sockets/ip-name-lookup@0.2.0 [method]resolve-address-stream.subscribe
//go:noescape
func wasmimport_ResolveAddressStreamSubscribe(self0 uint32) (result0 uint32)
// ResolveAddresses represents the imported function "resolve-addresses".
//
// 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>
//
// resolve-addresses: func(network: borrow<network>, name: string) -> result<resolve-address-stream,
// error-code>
//
//go:nosplit
func ResolveAddresses(network_ network.Network, name string) (result cm.OKResult[ResolveAddressStream, network.ErrorCode]) {
network0 := cm.Reinterpret[uint32](network_)
name0, name1 := cm.LowerString(name)
wasmimport_ResolveAddresses((uint32)(network0), (*uint8)(name0), (uint32)(name1), &result)
return
}
//go:wasmimport wasi:sockets/ip-name-lookup@0.2.0 resolve-addresses
//go:noescape
func wasmimport_ResolveAddresses(network0 uint32, name0 *uint8, name1 uint32, result *cm.OKResult[ResolveAddressStream, network.ErrorCode])
src/internal/wasi/sockets/v0.2.0/network/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/sockets/v0.2.0/network/network.wit.go
+278
View File
@@ -0,0 +1,278 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package network represents the imported interface "wasi:sockets/network@0.2.0".
package network
import (
"github.com/ydnar/wasm-tools-go/cm"
)
// Network represents the imported resource "wasi:sockets/network@0.2.0#network".
//
// An opaque resource that represents access to (a subset of) the network.
// This enables context-based security for networking.
// There is no need for this to map 1:1 to a physical network interface.
//
// resource network
type Network cm.Resource
// ResourceDrop represents the imported resource-drop for resource "network".
//
// Drops a resource handle.
//
//go:nosplit
func (self Network) ResourceDrop() {
self0 := cm.Reinterpret[uint32](self)
wasmimport_NetworkResourceDrop((uint32)(self0))
return
}
//go:wasmimport wasi:sockets/network@0.2.0 [resource-drop]network
//go:noescape
func wasmimport_NetworkResourceDrop(self0 uint32)
// ErrorCode represents the enum "wasi:sockets/network@0.2.0#error-code".
//
// 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.
//
// enum error-code {
// unknown,
// access-denied,
// not-supported,
// invalid-argument,
// out-of-memory,
// timeout,
// concurrency-conflict,
// not-in-progress,
// would-block,
// invalid-state,
// new-socket-limit,
// address-not-bindable,
// address-in-use,
// remote-unreachable,
// connection-refused,
// connection-reset,
// connection-aborted,
// datagram-too-large,
// name-unresolvable,
// temporary-resolver-failure,
// permanent-resolver-failure
// }
type ErrorCode uint8
const (
// Unknown error
ErrorCodeUnknown ErrorCode = iota
// Access denied.
//
// POSIX equivalent: EACCES, EPERM
ErrorCodeAccessDenied
// The operation is not supported.
//
// POSIX equivalent: EOPNOTSUPP
ErrorCodeNotSupported
// One of the arguments is invalid.
//
// POSIX equivalent: EINVAL
ErrorCodeInvalidArgument
// Not enough memory to complete the operation.
//
// POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY
ErrorCodeOutOfMemory
// The operation timed out before it could finish completely.
ErrorCodeTimeout
// This operation is incompatible with another asynchronous operation that is already
// in progress.
//
// POSIX equivalent: EALREADY
ErrorCodeConcurrencyConflict
// 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.
ErrorCodeNotInProgress
// 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.
ErrorCodeWouldBlock
// The operation is not valid in the socket's current state.
ErrorCodeInvalidState
// A new socket resource could not be created because of a system limit.
ErrorCodeNewSocketLimit
// A bind operation failed because the provided address is not an address that the
// `network` can bind to.
ErrorCodeAddressNotBindable
// A bind operation failed because the provided address is already in use or because
// there are no ephemeral ports available.
ErrorCodeAddressInUse
// The remote address is not reachable
ErrorCodeRemoteUnreachable
// The TCP connection was forcefully rejected
ErrorCodeConnectionRefused
// The TCP connection was reset.
ErrorCodeConnectionReset
// A TCP connection was aborted.
ErrorCodeConnectionAborted
// The size of a datagram sent to a UDP socket exceeded the maximum
// supported size.
ErrorCodeDatagramTooLarge
// Name does not exist or has no suitable associated IP addresses.
ErrorCodeNameUnresolvable
// A temporary failure in name resolution occurred.
ErrorCodeTemporaryResolverFailure
// A permanent failure in name resolution occurred.
ErrorCodePermanentResolverFailure
)
// IPAddressFamily represents the enum "wasi:sockets/network@0.2.0#ip-address-family".
//
// enum ip-address-family {
// ipv4,
// ipv6
// }
type IPAddressFamily uint8
const (
// Similar to `AF_INET` in POSIX.
IPAddressFamilyIPv4 IPAddressFamily = iota
// Similar to `AF_INET6` in POSIX.
IPAddressFamilyIPv6
)
// IPv4Address represents the tuple "wasi:sockets/network@0.2.0#ipv4-address".
//
// type ipv4-address = tuple<u8, u8, u8, u8>
type IPv4Address [4]uint8
// IPv6Address represents the tuple "wasi:sockets/network@0.2.0#ipv6-address".
//
// type ipv6-address = tuple<u16, u16, u16, u16, u16, u16, u16, u16>
type IPv6Address [8]uint16
// IPAddress represents the variant "wasi:sockets/network@0.2.0#ip-address".
//
// variant ip-address {
// ipv4(ipv4-address),
// ipv6(ipv6-address),
// }
type IPAddress cm.Variant[uint8, IPv6Address, IPv6Address]
// IPAddressIPv4 returns a [IPAddress] of case "ipv4".
func IPAddressIPv4(data IPv4Address) IPAddress {
return cm.New[IPAddress](0, data)
}
// IPv4 returns a non-nil *[IPv4Address] if [IPAddress] represents the variant case "ipv4".
func (self *IPAddress) IPv4() *IPv4Address {
return cm.Case[IPv4Address](self, 0)
}
// IPAddressIPv6 returns a [IPAddress] of case "ipv6".
func IPAddressIPv6(data IPv6Address) IPAddress {
return cm.New[IPAddress](1, data)
}
// IPv6 returns a non-nil *[IPv6Address] if [IPAddress] represents the variant case "ipv6".
func (self *IPAddress) IPv6() *IPv6Address {
return cm.Case[IPv6Address](self, 1)
}
// IPv4SocketAddress represents the record "wasi:sockets/network@0.2.0#ipv4-socket-address".
//
// record ipv4-socket-address {
// port: u16,
// address: ipv4-address,
// }
type IPv4SocketAddress struct {
// sin_port
Port uint16
// sin_addr
Address IPv4Address
}
// IPv6SocketAddress represents the record "wasi:sockets/network@0.2.0#ipv6-socket-address".
//
// record ipv6-socket-address {
// port: u16,
// flow-info: u32,
// address: ipv6-address,
// scope-id: u32,
// }
type IPv6SocketAddress struct {
// sin6_port
Port uint16
// sin6_flowinfo
FlowInfo uint32
// sin6_addr
Address IPv6Address
// sin6_scope_id
ScopeID uint32
}
// IPSocketAddress represents the variant "wasi:sockets/network@0.2.0#ip-socket-address".
//
// variant ip-socket-address {
// ipv4(ipv4-socket-address),
// ipv6(ipv6-socket-address),
// }
type IPSocketAddress cm.Variant[uint8, IPv6SocketAddress, IPv6SocketAddress]
// IPSocketAddressIPv4 returns a [IPSocketAddress] of case "ipv4".
func IPSocketAddressIPv4(data IPv4SocketAddress) IPSocketAddress {
return cm.New[IPSocketAddress](0, data)
}
// IPv4 returns a non-nil *[IPv4SocketAddress] if [IPSocketAddress] represents the variant case "ipv4".
func (self *IPSocketAddress) IPv4() *IPv4SocketAddress {
return cm.Case[IPv4SocketAddress](self, 0)
}
// IPSocketAddressIPv6 returns a [IPSocketAddress] of case "ipv6".
func IPSocketAddressIPv6(data IPv6SocketAddress) IPSocketAddress {
return cm.New[IPSocketAddress](1, data)
}
// IPv6 returns a non-nil *[IPv6SocketAddress] if [IPSocketAddress] represents the variant case "ipv6".
func (self *IPSocketAddress) IPv6() *IPv6SocketAddress {
return cm.Case[IPv6SocketAddress](self, 1)
}
src/internal/wasi/sockets/v0.2.0/tcp-create-socket/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/sockets/v0.2.0/tcp-create-socket/tcp-create-socket.wit.go
+54
View File
@@ -0,0 +1,54 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package tcpcreatesocket represents the imported interface "wasi:sockets/tcp-create-socket@0.2.0".
package tcpcreatesocket
import (
"github.com/ydnar/wasm-tools-go/cm"
"internal/wasi/sockets/v0.2.0/network"
"internal/wasi/sockets/v0.2.0/tcp"
)
// CreateTCPSocket represents the imported function "create-tcp-socket".
//
// 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>
//
// create-tcp-socket: func(address-family: ip-address-family) -> result<tcp-socket,
// error-code>
//
//go:nosplit
func CreateTCPSocket(addressFamily network.IPAddressFamily) (result cm.OKResult[tcp.TCPSocket, network.ErrorCode]) {
addressFamily0 := (uint32)(addressFamily)
wasmimport_CreateTCPSocket((uint32)(addressFamily0), &result)
return
}
//go:wasmimport wasi:sockets/tcp-create-socket@0.2.0 create-tcp-socket
//go:noescape
func wasmimport_CreateTCPSocket(addressFamily0 uint32, result *cm.OKResult[tcp.TCPSocket, network.ErrorCode])
src/internal/wasi/sockets/v0.2.0/tcp/abi.go
+71
View File
@@ -0,0 +1,71 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
package tcp
import (
"github.com/ydnar/wasm-tools-go/cm"
"internal/wasi/sockets/v0.2.0/network"
)
func lower_IPv4Address(v network.IPv4Address) (f0 uint32, f1 uint32, f2 uint32, f3 uint32) {
f0 = (uint32)(v[0])
f1 = (uint32)(v[1])
f2 = (uint32)(v[2])
f3 = (uint32)(v[3])
return
}
func lower_IPv4SocketAddress(v network.IPv4SocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32) {
f0 = (uint32)(v.Port)
f1, f2, f3, f4 = lower_IPv4Address(v.Address)
return
}
func lower_IPv6Address(v network.IPv6Address) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32) {
f0 = (uint32)(v[0])
f1 = (uint32)(v[1])
f2 = (uint32)(v[2])
f3 = (uint32)(v[3])
f4 = (uint32)(v[4])
f5 = (uint32)(v[5])
f6 = (uint32)(v[6])
f7 = (uint32)(v[7])
return
}
func lower_IPv6SocketAddress(v network.IPv6SocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32, f8 uint32, f9 uint32, f10 uint32) {
f0 = (uint32)(v.Port)
f1 = (uint32)(v.FlowInfo)
f2, f3, f4, f5, f6, f7, f8, f9 = lower_IPv6Address(v.Address)
f10 = (uint32)(v.ScopeID)
return
}
func lower_IPSocketAddress(v network.IPSocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32, f8 uint32, f9 uint32, f10 uint32, f11 uint32) {
f0 = (uint32)(cm.Tag(&v))
switch f0 {
case 0: // ipv4
v1, v2, v3, v4, v5 := lower_IPv4SocketAddress(*v.IPv4())
f1 = (uint32)(v1)
f2 = (uint32)(v2)
f3 = (uint32)(v3)
f4 = (uint32)(v4)
f5 = (uint32)(v5)
case 1: // ipv6
v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11 := lower_IPv6SocketAddress(*v.IPv6())
f1 = (uint32)(v1)
f2 = (uint32)(v2)
f3 = (uint32)(v3)
f4 = (uint32)(v4)
f5 = (uint32)(v5)
f6 = (uint32)(v6)
f7 = (uint32)(v7)
f8 = (uint32)(v8)
f9 = (uint32)(v9)
f10 = (uint32)(v10)
f11 = (uint32)(v11)
}
return
}
src/internal/wasi/sockets/v0.2.0/tcp/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/sockets/v0.2.0/tcp/tcp.wit.go
+839
View File
@@ -0,0 +1,839 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package tcp represents the imported interface "wasi:sockets/tcp@0.2.0".
package tcp
import (
"github.com/ydnar/wasm-tools-go/cm"
monotonicclock "internal/wasi/clocks/v0.2.0/monotonic-clock"
"internal/wasi/io/v0.2.0/poll"
"internal/wasi/io/v0.2.0/streams"
"internal/wasi/sockets/v0.2.0/network"
)
// ShutdownType represents the enum "wasi:sockets/tcp@0.2.0#shutdown-type".
//
// enum shutdown-type {
// receive,
// send,
// both
// }
type ShutdownType uint8
const (
// Similar to `SHUT_RD` in POSIX.
ShutdownTypeReceive ShutdownType = iota
// Similar to `SHUT_WR` in POSIX.
ShutdownTypeSend
// Similar to `SHUT_RDWR` in POSIX.
ShutdownTypeBoth
)
// TCPSocket represents the imported resource "wasi:sockets/tcp@0.2.0#tcp-socket".
//
// A TCP socket resource.
//
// The socket can be in one of the following states:
// - `unbound`
// - `bind-in-progress`
// - `bound` (See note below)
// - `listen-in-progress`
// - `listening`
// - `connect-in-progress`
// - `connected`
// - `closed`
// See <https://github.com/WebAssembly/wasi-sockets/TcpSocketOperationalSemantics.md>
// for a more information.
//
// Note: Except where explicitly mentioned, whenever this documentation uses
// the term "bound" without backticks it actually means: in the `bound` state *or
// higher*.
// (i.e. `bound`, `listen-in-progress`, `listening`, `connect-in-progress` or `connected`)
//
// In addition to the general error codes documented on the
// `network::error-code` type, TCP socket methods may always return
// `error(invalid-state)` when in the `closed` state.
//
// resource tcp-socket
type TCPSocket cm.Resource
// ResourceDrop represents the imported resource-drop for resource "tcp-socket".
//
// Drops a resource handle.
//
//go:nosplit
func (self TCPSocket) ResourceDrop() {
self0 := cm.Reinterpret[uint32](self)
wasmimport_TCPSocketResourceDrop((uint32)(self0))
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [resource-drop]tcp-socket
//go:noescape
func wasmimport_TCPSocketResourceDrop(self0 uint32)
// Accept represents the imported method "accept".
//
// 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>
//
// accept: func() -> result<tuple<tcp-socket, input-stream, output-stream>, error-code>
//
//go:nosplit
func (self TCPSocket) Accept() (result cm.OKResult[cm.Tuple3[TCPSocket, streams.InputStream, streams.OutputStream], network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_TCPSocketAccept((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.accept
//go:noescape
func wasmimport_TCPSocketAccept(self0 uint32, result *cm.OKResult[cm.Tuple3[TCPSocket, streams.InputStream, streams.OutputStream], network.ErrorCode])
// AddressFamily represents the imported method "address-family".
//
// Whether this is a IPv4 or IPv6 socket.
//
// Equivalent to the SO_DOMAIN socket option.
//
// address-family: func() -> ip-address-family
//
//go:nosplit
func (self TCPSocket) AddressFamily() (result network.IPAddressFamily) {
self0 := cm.Reinterpret[uint32](self)
result0 := wasmimport_TCPSocketAddressFamily((uint32)(self0))
result = (network.IPAddressFamily)((uint32)(result0))
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.address-family
//go:noescape
func wasmimport_TCPSocketAddressFamily(self0 uint32) (result0 uint32)
// FinishBind represents the imported method "finish-bind".
//
// finish-bind: func() -> result<_, error-code>
//
//go:nosplit
func (self TCPSocket) FinishBind() (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_TCPSocketFinishBind((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.finish-bind
//go:noescape
func wasmimport_TCPSocketFinishBind(self0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
// FinishConnect represents the imported method "finish-connect".
//
// finish-connect: func() -> result<tuple<input-stream, output-stream>, error-code>
//
//go:nosplit
func (self TCPSocket) FinishConnect() (result cm.OKResult[cm.Tuple[streams.InputStream, streams.OutputStream], network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_TCPSocketFinishConnect((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.finish-connect
//go:noescape
func wasmimport_TCPSocketFinishConnect(self0 uint32, result *cm.OKResult[cm.Tuple[streams.InputStream, streams.OutputStream], network.ErrorCode])
// FinishListen represents the imported method "finish-listen".
//
// finish-listen: func() -> result<_, error-code>
//
//go:nosplit
func (self TCPSocket) FinishListen() (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_TCPSocketFinishListen((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.finish-listen
//go:noescape
func wasmimport_TCPSocketFinishListen(self0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
// HopLimit represents the imported method "hop-limit".
//
// 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.
//
// hop-limit: func() -> result<u8, error-code>
//
//go:nosplit
func (self TCPSocket) HopLimit() (result cm.OKResult[uint8, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_TCPSocketHopLimit((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.hop-limit
//go:noescape
func wasmimport_TCPSocketHopLimit(self0 uint32, result *cm.OKResult[uint8, network.ErrorCode])
// IsListening represents the imported method "is-listening".
//
// Whether the socket is in the `listening` state.
//
// Equivalent to the SO_ACCEPTCONN socket option.
//
// is-listening: func() -> bool
//
//go:nosplit
func (self TCPSocket) IsListening() (result bool) {
self0 := cm.Reinterpret[uint32](self)
result0 := wasmimport_TCPSocketIsListening((uint32)(self0))
result = cm.U32ToBool((uint32)(result0))
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.is-listening
//go:noescape
func wasmimport_TCPSocketIsListening(self0 uint32) (result0 uint32)
// KeepAliveCount represents the imported method "keep-alive-count".
//
// 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.
//
// keep-alive-count: func() -> result<u32, error-code>
//
//go:nosplit
func (self TCPSocket) KeepAliveCount() (result cm.OKResult[uint32, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_TCPSocketKeepAliveCount((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.keep-alive-count
//go:noescape
func wasmimport_TCPSocketKeepAliveCount(self0 uint32, result *cm.OKResult[uint32, network.ErrorCode])
// KeepAliveEnabled represents the imported method "keep-alive-enabled".
//
// 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.
//
// keep-alive-enabled: func() -> result<bool, error-code>
//
//go:nosplit
func (self TCPSocket) KeepAliveEnabled() (result cm.OKResult[bool, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_TCPSocketKeepAliveEnabled((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.keep-alive-enabled
//go:noescape
func wasmimport_TCPSocketKeepAliveEnabled(self0 uint32, result *cm.OKResult[bool, network.ErrorCode])
// KeepAliveIdleTime represents the imported method "keep-alive-idle-time".
//
// 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.
//
// keep-alive-idle-time: func() -> result<duration, error-code>
//
//go:nosplit
func (self TCPSocket) KeepAliveIdleTime() (result cm.OKResult[monotonicclock.Duration, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_TCPSocketKeepAliveIdleTime((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.keep-alive-idle-time
//go:noescape
func wasmimport_TCPSocketKeepAliveIdleTime(self0 uint32, result *cm.OKResult[monotonicclock.Duration, network.ErrorCode])
// KeepAliveInterval represents the imported method "keep-alive-interval".
//
// 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.
//
// keep-alive-interval: func() -> result<duration, error-code>
//
//go:nosplit
func (self TCPSocket) KeepAliveInterval() (result cm.OKResult[monotonicclock.Duration, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_TCPSocketKeepAliveInterval((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.keep-alive-interval
//go:noescape
func wasmimport_TCPSocketKeepAliveInterval(self0 uint32, result *cm.OKResult[monotonicclock.Duration, network.ErrorCode])
// LocalAddress represents the imported method "local-address".
//
// 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>
//
// local-address: func() -> result<ip-socket-address, error-code>
//
//go:nosplit
func (self TCPSocket) LocalAddress() (result cm.OKResult[network.IPSocketAddress, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_TCPSocketLocalAddress((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.local-address
//go:noescape
func wasmimport_TCPSocketLocalAddress(self0 uint32, result *cm.OKResult[network.IPSocketAddress, network.ErrorCode])
// ReceiveBufferSize represents the imported method "receive-buffer-size".
//
// 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.
//
// receive-buffer-size: func() -> result<u64, error-code>
//
//go:nosplit
func (self TCPSocket) ReceiveBufferSize() (result cm.OKResult[uint64, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_TCPSocketReceiveBufferSize((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.receive-buffer-size
//go:noescape
func wasmimport_TCPSocketReceiveBufferSize(self0 uint32, result *cm.OKResult[uint64, network.ErrorCode])
// RemoteAddress represents the imported method "remote-address".
//
// 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>
//
// remote-address: func() -> result<ip-socket-address, error-code>
//
//go:nosplit
func (self TCPSocket) RemoteAddress() (result cm.OKResult[network.IPSocketAddress, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_TCPSocketRemoteAddress((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.remote-address
//go:noescape
func wasmimport_TCPSocketRemoteAddress(self0 uint32, result *cm.OKResult[network.IPSocketAddress, network.ErrorCode])
// SendBufferSize represents the imported method "send-buffer-size".
//
// send-buffer-size: func() -> result<u64, error-code>
//
//go:nosplit
func (self TCPSocket) SendBufferSize() (result cm.OKResult[uint64, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_TCPSocketSendBufferSize((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.send-buffer-size
//go:noescape
func wasmimport_TCPSocketSendBufferSize(self0 uint32, result *cm.OKResult[uint64, network.ErrorCode])
// SetHopLimit represents the imported method "set-hop-limit".
//
// set-hop-limit: func(value: u8) -> result<_, error-code>
//
//go:nosplit
func (self TCPSocket) SetHopLimit(value uint8) (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
value0 := (uint32)(value)
wasmimport_TCPSocketSetHopLimit((uint32)(self0), (uint32)(value0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-hop-limit
//go:noescape
func wasmimport_TCPSocketSetHopLimit(self0 uint32, value0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
// SetKeepAliveCount represents the imported method "set-keep-alive-count".
//
// set-keep-alive-count: func(value: u32) -> result<_, error-code>
//
//go:nosplit
func (self TCPSocket) SetKeepAliveCount(value uint32) (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
value0 := (uint32)(value)
wasmimport_TCPSocketSetKeepAliveCount((uint32)(self0), (uint32)(value0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-keep-alive-count
//go:noescape
func wasmimport_TCPSocketSetKeepAliveCount(self0 uint32, value0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
// SetKeepAliveEnabled represents the imported method "set-keep-alive-enabled".
//
// set-keep-alive-enabled: func(value: bool) -> result<_, error-code>
//
//go:nosplit
func (self TCPSocket) SetKeepAliveEnabled(value bool) (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
value0 := cm.BoolToU32(value)
wasmimport_TCPSocketSetKeepAliveEnabled((uint32)(self0), (uint32)(value0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-keep-alive-enabled
//go:noescape
func wasmimport_TCPSocketSetKeepAliveEnabled(self0 uint32, value0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
// SetKeepAliveIdleTime represents the imported method "set-keep-alive-idle-time".
//
// set-keep-alive-idle-time: func(value: duration) -> result<_, error-code>
//
//go:nosplit
func (self TCPSocket) SetKeepAliveIdleTime(value monotonicclock.Duration) (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
value0 := (uint64)(value)
wasmimport_TCPSocketSetKeepAliveIdleTime((uint32)(self0), (uint64)(value0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-keep-alive-idle-time
//go:noescape
func wasmimport_TCPSocketSetKeepAliveIdleTime(self0 uint32, value0 uint64, result *cm.ErrResult[struct{}, network.ErrorCode])
// SetKeepAliveInterval represents the imported method "set-keep-alive-interval".
//
// set-keep-alive-interval: func(value: duration) -> result<_, error-code>
//
//go:nosplit
func (self TCPSocket) SetKeepAliveInterval(value monotonicclock.Duration) (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
value0 := (uint64)(value)
wasmimport_TCPSocketSetKeepAliveInterval((uint32)(self0), (uint64)(value0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-keep-alive-interval
//go:noescape
func wasmimport_TCPSocketSetKeepAliveInterval(self0 uint32, value0 uint64, result *cm.ErrResult[struct{}, network.ErrorCode])
// SetListenBacklogSize represents the imported method "set-listen-backlog-size".
//
// 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.
//
// set-listen-backlog-size: func(value: u64) -> result<_, error-code>
//
//go:nosplit
func (self TCPSocket) SetListenBacklogSize(value uint64) (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
value0 := (uint64)(value)
wasmimport_TCPSocketSetListenBacklogSize((uint32)(self0), (uint64)(value0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-listen-backlog-size
//go:noescape
func wasmimport_TCPSocketSetListenBacklogSize(self0 uint32, value0 uint64, result *cm.ErrResult[struct{}, network.ErrorCode])
// SetReceiveBufferSize represents the imported method "set-receive-buffer-size".
//
// set-receive-buffer-size: func(value: u64) -> result<_, error-code>
//
//go:nosplit
func (self TCPSocket) SetReceiveBufferSize(value uint64) (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
value0 := (uint64)(value)
wasmimport_TCPSocketSetReceiveBufferSize((uint32)(self0), (uint64)(value0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-receive-buffer-size
//go:noescape
func wasmimport_TCPSocketSetReceiveBufferSize(self0 uint32, value0 uint64, result *cm.ErrResult[struct{}, network.ErrorCode])
// SetSendBufferSize represents the imported method "set-send-buffer-size".
//
// set-send-buffer-size: func(value: u64) -> result<_, error-code>
//
//go:nosplit
func (self TCPSocket) SetSendBufferSize(value uint64) (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
value0 := (uint64)(value)
wasmimport_TCPSocketSetSendBufferSize((uint32)(self0), (uint64)(value0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-send-buffer-size
//go:noescape
func wasmimport_TCPSocketSetSendBufferSize(self0 uint32, value0 uint64, result *cm.ErrResult[struct{}, network.ErrorCode])
// Shutdown represents the imported method "shutdown".
//
// 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>
//
// shutdown: func(shutdown-type: shutdown-type) -> result<_, error-code>
//
//go:nosplit
func (self TCPSocket) Shutdown(shutdownType ShutdownType) (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
shutdownType0 := (uint32)(shutdownType)
wasmimport_TCPSocketShutdown((uint32)(self0), (uint32)(shutdownType0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.shutdown
//go:noescape
func wasmimport_TCPSocketShutdown(self0 uint32, shutdownType0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
// StartBind represents the imported method "start-bind".
//
// 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>
//
// start-bind: func(network: borrow<network>, local-address: ip-socket-address) ->
// result<_, error-code>
//
//go:nosplit
func (self TCPSocket) StartBind(network_ network.Network, localAddress network.IPSocketAddress) (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
network0 := cm.Reinterpret[uint32](network_)
localAddress0, localAddress1, localAddress2, localAddress3, localAddress4, localAddress5, localAddress6, localAddress7, localAddress8, localAddress9, localAddress10, localAddress11 := lower_IPSocketAddress(localAddress)
wasmimport_TCPSocketStartBind((uint32)(self0), (uint32)(network0), (uint32)(localAddress0), (uint32)(localAddress1), (uint32)(localAddress2), (uint32)(localAddress3), (uint32)(localAddress4), (uint32)(localAddress5), (uint32)(localAddress6), (uint32)(localAddress7), (uint32)(localAddress8), (uint32)(localAddress9), (uint32)(localAddress10), (uint32)(localAddress11), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.start-bind
//go:noescape
func wasmimport_TCPSocketStartBind(self0 uint32, network0 uint32, localAddress0 uint32, localAddress1 uint32, localAddress2 uint32, localAddress3 uint32, localAddress4 uint32, localAddress5 uint32, localAddress6 uint32, localAddress7 uint32, localAddress8 uint32, localAddress9 uint32, localAddress10 uint32, localAddress11 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
// StartConnect represents the imported method "start-connect".
//
// 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>
//
// start-connect: func(network: borrow<network>, remote-address: ip-socket-address)
// -> result<_, error-code>
//
//go:nosplit
func (self TCPSocket) StartConnect(network_ network.Network, remoteAddress network.IPSocketAddress) (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
network0 := cm.Reinterpret[uint32](network_)
remoteAddress0, remoteAddress1, remoteAddress2, remoteAddress3, remoteAddress4, remoteAddress5, remoteAddress6, remoteAddress7, remoteAddress8, remoteAddress9, remoteAddress10, remoteAddress11 := lower_IPSocketAddress(remoteAddress)
wasmimport_TCPSocketStartConnect((uint32)(self0), (uint32)(network0), (uint32)(remoteAddress0), (uint32)(remoteAddress1), (uint32)(remoteAddress2), (uint32)(remoteAddress3), (uint32)(remoteAddress4), (uint32)(remoteAddress5), (uint32)(remoteAddress6), (uint32)(remoteAddress7), (uint32)(remoteAddress8), (uint32)(remoteAddress9), (uint32)(remoteAddress10), (uint32)(remoteAddress11), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.start-connect
//go:noescape
func wasmimport_TCPSocketStartConnect(self0 uint32, network0 uint32, remoteAddress0 uint32, remoteAddress1 uint32, remoteAddress2 uint32, remoteAddress3 uint32, remoteAddress4 uint32, remoteAddress5 uint32, remoteAddress6 uint32, remoteAddress7 uint32, remoteAddress8 uint32, remoteAddress9 uint32, remoteAddress10 uint32, remoteAddress11 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
// StartListen represents the imported method "start-listen".
//
// 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>
//
// start-listen: func() -> result<_, error-code>
//
//go:nosplit
func (self TCPSocket) StartListen() (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_TCPSocketStartListen((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.start-listen
//go:noescape
func wasmimport_TCPSocketStartListen(self0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
// Subscribe represents the imported method "subscribe".
//
// 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.
//
// subscribe: func() -> pollable
//
//go:nosplit
func (self TCPSocket) Subscribe() (result poll.Pollable) {
self0 := cm.Reinterpret[uint32](self)
result0 := wasmimport_TCPSocketSubscribe((uint32)(self0))
result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
return
}
//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.subscribe
//go:noescape
func wasmimport_TCPSocketSubscribe(self0 uint32) (result0 uint32)
src/internal/wasi/sockets/v0.2.0/udp-create-socket/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/sockets/v0.2.0/udp-create-socket/udp-create-socket.wit.go
+54
View File
@@ -0,0 +1,54 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package udpcreatesocket represents the imported interface "wasi:sockets/udp-create-socket@0.2.0".
package udpcreatesocket
import (
"github.com/ydnar/wasm-tools-go/cm"
"internal/wasi/sockets/v0.2.0/network"
"internal/wasi/sockets/v0.2.0/udp"
)
// CreateUDPSocket represents the imported function "create-udp-socket".
//
// 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>
//
// create-udp-socket: func(address-family: ip-address-family) -> result<udp-socket,
// error-code>
//
//go:nosplit
func CreateUDPSocket(addressFamily network.IPAddressFamily) (result cm.OKResult[udp.UDPSocket, network.ErrorCode]) {
addressFamily0 := (uint32)(addressFamily)
wasmimport_CreateUDPSocket((uint32)(addressFamily0), &result)
return
}
//go:wasmimport wasi:sockets/udp-create-socket@0.2.0 create-udp-socket
//go:noescape
func wasmimport_CreateUDPSocket(addressFamily0 uint32, result *cm.OKResult[udp.UDPSocket, network.ErrorCode])
src/internal/wasi/sockets/v0.2.0/udp/abi.go
+92
View File
@@ -0,0 +1,92 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
package udp
import (
"github.com/ydnar/wasm-tools-go/cm"
"internal/wasi/sockets/v0.2.0/network"
)
func lower_IPv4Address(v network.IPv4Address) (f0 uint32, f1 uint32, f2 uint32, f3 uint32) {
f0 = (uint32)(v[0])
f1 = (uint32)(v[1])
f2 = (uint32)(v[2])
f3 = (uint32)(v[3])
return
}
func lower_IPv4SocketAddress(v network.IPv4SocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32) {
f0 = (uint32)(v.Port)
f1, f2, f3, f4 = lower_IPv4Address(v.Address)
return
}
func lower_IPv6Address(v network.IPv6Address) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32) {
f0 = (uint32)(v[0])
f1 = (uint32)(v[1])
f2 = (uint32)(v[2])
f3 = (uint32)(v[3])
f4 = (uint32)(v[4])
f5 = (uint32)(v[5])
f6 = (uint32)(v[6])
f7 = (uint32)(v[7])
return
}
func lower_IPv6SocketAddress(v network.IPv6SocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32, f8 uint32, f9 uint32, f10 uint32) {
f0 = (uint32)(v.Port)
f1 = (uint32)(v.FlowInfo)
f2, f3, f4, f5, f6, f7, f8, f9 = lower_IPv6Address(v.Address)
f10 = (uint32)(v.ScopeID)
return
}
func lower_IPSocketAddress(v network.IPSocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32, f8 uint32, f9 uint32, f10 uint32, f11 uint32) {
f0 = (uint32)(cm.Tag(&v))
switch f0 {
case 0: // ipv4
v1, v2, v3, v4, v5 := lower_IPv4SocketAddress(*v.IPv4())
f1 = (uint32)(v1)
f2 = (uint32)(v2)
f3 = (uint32)(v3)
f4 = (uint32)(v4)
f5 = (uint32)(v5)
case 1: // ipv6
v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11 := lower_IPv6SocketAddress(*v.IPv6())
f1 = (uint32)(v1)
f2 = (uint32)(v2)
f3 = (uint32)(v3)
f4 = (uint32)(v4)
f5 = (uint32)(v5)
f6 = (uint32)(v6)
f7 = (uint32)(v7)
f8 = (uint32)(v8)
f9 = (uint32)(v9)
f10 = (uint32)(v10)
f11 = (uint32)(v11)
}
return
}
func lower_OptionIPSocketAddress(v cm.Option[network.IPSocketAddress]) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32, f8 uint32, f9 uint32, f10 uint32, f11 uint32, f12 uint32) {
some := v.Some()
if some != nil {
f0 = 1
v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12 := lower_IPSocketAddress(*some)
f1 = (uint32)(v1)
f2 = (uint32)(v2)
f3 = (uint32)(v3)
f4 = (uint32)(v4)
f5 = (uint32)(v5)
f6 = (uint32)(v6)
f7 = (uint32)(v7)
f8 = (uint32)(v8)
f9 = (uint32)(v9)
f10 = (uint32)(v10)
f11 = (uint32)(v11)
f12 = (uint32)(v12)
}
return
}
src/internal/wasi/sockets/v0.2.0/udp/empty.s
+3
View File
@@ -0,0 +1,3 @@
// This file exists for testing this package without WebAssembly,
// allowing empty function bodies with a //go:wasmimport directive.
// See https://pkg.go.dev/cmd/compile for more information.
src/internal/wasi/sockets/v0.2.0/udp/udp.wit.go
+643
View File
@@ -0,0 +1,643 @@
// Code generated by wit-bindgen-go. DO NOT EDIT.
//go:build !wasip1
// Package udp represents the imported interface "wasi:sockets/udp@0.2.0".
package udp
import (
"github.com/ydnar/wasm-tools-go/cm"
"internal/wasi/io/v0.2.0/poll"
"internal/wasi/sockets/v0.2.0/network"
)
// IncomingDatagram represents the record "wasi:sockets/udp@0.2.0#incoming-datagram".
//
// A received datagram.
//
// record incoming-datagram {
// data: list<u8>,
// remote-address: ip-socket-address,
// }
type IncomingDatagram struct {
// The payload.
//
// Theoretical max size: ~64 KiB. In practice, typically less than 1500 bytes.
Data cm.List[uint8]
// 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`.
RemoteAddress network.IPSocketAddress
}
// OutgoingDatagram represents the record "wasi:sockets/udp@0.2.0#outgoing-datagram".
//
// A datagram to be sent out.
//
// record outgoing-datagram {
// data: list<u8>,
// remote-address: option<ip-socket-address>,
// }
type OutgoingDatagram struct {
// The payload.
Data cm.List[uint8]
// 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`.
RemoteAddress cm.Option[network.IPSocketAddress]
}
// UDPSocket represents the imported resource "wasi:sockets/udp@0.2.0#udp-socket".
//
// A UDP socket handle.
//
// resource udp-socket
type UDPSocket cm.Resource
// ResourceDrop represents the imported resource-drop for resource "udp-socket".
//
// Drops a resource handle.
//
//go:nosplit
func (self UDPSocket) ResourceDrop() {
self0 := cm.Reinterpret[uint32](self)
wasmimport_UDPSocketResourceDrop((uint32)(self0))
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [resource-drop]udp-socket
//go:noescape
func wasmimport_UDPSocketResourceDrop(self0 uint32)
// AddressFamily represents the imported method "address-family".
//
// Whether this is a IPv4 or IPv6 socket.
//
// Equivalent to the SO_DOMAIN socket option.
//
// address-family: func() -> ip-address-family
//
//go:nosplit
func (self UDPSocket) AddressFamily() (result network.IPAddressFamily) {
self0 := cm.Reinterpret[uint32](self)
result0 := wasmimport_UDPSocketAddressFamily((uint32)(self0))
result = (network.IPAddressFamily)((uint32)(result0))
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.address-family
//go:noescape
func wasmimport_UDPSocketAddressFamily(self0 uint32) (result0 uint32)
// FinishBind represents the imported method "finish-bind".
//
// finish-bind: func() -> result<_, error-code>
//
//go:nosplit
func (self UDPSocket) FinishBind() (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_UDPSocketFinishBind((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.finish-bind
//go:noescape
func wasmimport_UDPSocketFinishBind(self0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
// LocalAddress represents the imported method "local-address".
//
// 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>
//
// local-address: func() -> result<ip-socket-address, error-code>
//
//go:nosplit
func (self UDPSocket) LocalAddress() (result cm.OKResult[network.IPSocketAddress, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_UDPSocketLocalAddress((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.local-address
//go:noescape
func wasmimport_UDPSocketLocalAddress(self0 uint32, result *cm.OKResult[network.IPSocketAddress, network.ErrorCode])
// ReceiveBufferSize represents the imported method "receive-buffer-size".
//
// 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.
//
// receive-buffer-size: func() -> result<u64, error-code>
//
//go:nosplit
func (self UDPSocket) ReceiveBufferSize() (result cm.OKResult[uint64, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_UDPSocketReceiveBufferSize((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.receive-buffer-size
//go:noescape
func wasmimport_UDPSocketReceiveBufferSize(self0 uint32, result *cm.OKResult[uint64, network.ErrorCode])
// RemoteAddress represents the imported method "remote-address".
//
// 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>
//
// remote-address: func() -> result<ip-socket-address, error-code>
//
//go:nosplit
func (self UDPSocket) RemoteAddress() (result cm.OKResult[network.IPSocketAddress, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_UDPSocketRemoteAddress((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.remote-address
//go:noescape
func wasmimport_UDPSocketRemoteAddress(self0 uint32, result *cm.OKResult[network.IPSocketAddress, network.ErrorCode])
// SendBufferSize represents the imported method "send-buffer-size".
//
// send-buffer-size: func() -> result<u64, error-code>
//
//go:nosplit
func (self UDPSocket) SendBufferSize() (result cm.OKResult[uint64, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_UDPSocketSendBufferSize((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.send-buffer-size
//go:noescape
func wasmimport_UDPSocketSendBufferSize(self0 uint32, result *cm.OKResult[uint64, network.ErrorCode])
// SetReceiveBufferSize represents the imported method "set-receive-buffer-size".
//
// set-receive-buffer-size: func(value: u64) -> result<_, error-code>
//
//go:nosplit
func (self UDPSocket) SetReceiveBufferSize(value uint64) (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
value0 := (uint64)(value)
wasmimport_UDPSocketSetReceiveBufferSize((uint32)(self0), (uint64)(value0), &result)
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.set-receive-buffer-size
//go:noescape
func wasmimport_UDPSocketSetReceiveBufferSize(self0 uint32, value0 uint64, result *cm.ErrResult[struct{}, network.ErrorCode])
// SetSendBufferSize represents the imported method "set-send-buffer-size".
//
// set-send-buffer-size: func(value: u64) -> result<_, error-code>
//
//go:nosplit
func (self UDPSocket) SetSendBufferSize(value uint64) (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
value0 := (uint64)(value)
wasmimport_UDPSocketSetSendBufferSize((uint32)(self0), (uint64)(value0), &result)
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.set-send-buffer-size
//go:noescape
func wasmimport_UDPSocketSetSendBufferSize(self0 uint32, value0 uint64, result *cm.ErrResult[struct{}, network.ErrorCode])
// SetUnicastHopLimit represents the imported method "set-unicast-hop-limit".
//
// set-unicast-hop-limit: func(value: u8) -> result<_, error-code>
//
//go:nosplit
func (self UDPSocket) SetUnicastHopLimit(value uint8) (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
value0 := (uint32)(value)
wasmimport_UDPSocketSetUnicastHopLimit((uint32)(self0), (uint32)(value0), &result)
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.set-unicast-hop-limit
//go:noescape
func wasmimport_UDPSocketSetUnicastHopLimit(self0 uint32, value0 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
// StartBind represents the imported method "start-bind".
//
// 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>
//
// start-bind: func(network: borrow<network>, local-address: ip-socket-address) ->
// result<_, error-code>
//
//go:nosplit
func (self UDPSocket) StartBind(network_ network.Network, localAddress network.IPSocketAddress) (result cm.ErrResult[struct{}, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
network0 := cm.Reinterpret[uint32](network_)
localAddress0, localAddress1, localAddress2, localAddress3, localAddress4, localAddress5, localAddress6, localAddress7, localAddress8, localAddress9, localAddress10, localAddress11 := lower_IPSocketAddress(localAddress)
wasmimport_UDPSocketStartBind((uint32)(self0), (uint32)(network0), (uint32)(localAddress0), (uint32)(localAddress1), (uint32)(localAddress2), (uint32)(localAddress3), (uint32)(localAddress4), (uint32)(localAddress5), (uint32)(localAddress6), (uint32)(localAddress7), (uint32)(localAddress8), (uint32)(localAddress9), (uint32)(localAddress10), (uint32)(localAddress11), &result)
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.start-bind
//go:noescape
func wasmimport_UDPSocketStartBind(self0 uint32, network0 uint32, localAddress0 uint32, localAddress1 uint32, localAddress2 uint32, localAddress3 uint32, localAddress4 uint32, localAddress5 uint32, localAddress6 uint32, localAddress7 uint32, localAddress8 uint32, localAddress9 uint32, localAddress10 uint32, localAddress11 uint32, result *cm.ErrResult[struct{}, network.ErrorCode])
// Stream represents the imported method "stream".
//
// 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:
//
// 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>
//
// %stream: func(remote-address: option<ip-socket-address>) -> result<tuple<incoming-datagram-stream,
// outgoing-datagram-stream>, error-code>
//
//go:nosplit
func (self UDPSocket) Stream(remoteAddress cm.Option[network.IPSocketAddress]) (result cm.OKResult[cm.Tuple[IncomingDatagramStream, OutgoingDatagramStream], network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
remoteAddress0, remoteAddress1, remoteAddress2, remoteAddress3, remoteAddress4, remoteAddress5, remoteAddress6, remoteAddress7, remoteAddress8, remoteAddress9, remoteAddress10, remoteAddress11, remoteAddress12 := lower_OptionIPSocketAddress(remoteAddress)
wasmimport_UDPSocketStream((uint32)(self0), (uint32)(remoteAddress0), (uint32)(remoteAddress1), (uint32)(remoteAddress2), (uint32)(remoteAddress3), (uint32)(remoteAddress4), (uint32)(remoteAddress5), (uint32)(remoteAddress6), (uint32)(remoteAddress7), (uint32)(remoteAddress8), (uint32)(remoteAddress9), (uint32)(remoteAddress10), (uint32)(remoteAddress11), (uint32)(remoteAddress12), &result)
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.stream
//go:noescape
func wasmimport_UDPSocketStream(self0 uint32, remoteAddress0 uint32, remoteAddress1 uint32, remoteAddress2 uint32, remoteAddress3 uint32, remoteAddress4 uint32, remoteAddress5 uint32, remoteAddress6 uint32, remoteAddress7 uint32, remoteAddress8 uint32, remoteAddress9 uint32, remoteAddress10 uint32, remoteAddress11 uint32, remoteAddress12 uint32, result *cm.OKResult[cm.Tuple[IncomingDatagramStream, OutgoingDatagramStream], network.ErrorCode])
// Subscribe represents the imported method "subscribe".
//
// 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.
//
// subscribe: func() -> pollable
//
//go:nosplit
func (self UDPSocket) Subscribe() (result poll.Pollable) {
self0 := cm.Reinterpret[uint32](self)
result0 := wasmimport_UDPSocketSubscribe((uint32)(self0))
result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.subscribe
//go:noescape
func wasmimport_UDPSocketSubscribe(self0 uint32) (result0 uint32)
// UnicastHopLimit represents the imported method "unicast-hop-limit".
//
// 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.
//
// unicast-hop-limit: func() -> result<u8, error-code>
//
//go:nosplit
func (self UDPSocket) UnicastHopLimit() (result cm.OKResult[uint8, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_UDPSocketUnicastHopLimit((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.unicast-hop-limit
//go:noescape
func wasmimport_UDPSocketUnicastHopLimit(self0 uint32, result *cm.OKResult[uint8, network.ErrorCode])
// IncomingDatagramStream represents the imported resource "wasi:sockets/udp@0.2.0#incoming-datagram-stream".
//
// resource incoming-datagram-stream
type IncomingDatagramStream cm.Resource
// ResourceDrop represents the imported resource-drop for resource "incoming-datagram-stream".
//
// Drops a resource handle.
//
//go:nosplit
func (self IncomingDatagramStream) ResourceDrop() {
self0 := cm.Reinterpret[uint32](self)
wasmimport_IncomingDatagramStreamResourceDrop((uint32)(self0))
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [resource-drop]incoming-datagram-stream
//go:noescape
func wasmimport_IncomingDatagramStreamResourceDrop(self0 uint32)
// Receive represents the imported method "receive".
//
// 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>
//
// receive: func(max-results: u64) -> result<list<incoming-datagram>, error-code>
//
//go:nosplit
func (self IncomingDatagramStream) Receive(maxResults uint64) (result cm.OKResult[cm.List[IncomingDatagram], network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
maxResults0 := (uint64)(maxResults)
wasmimport_IncomingDatagramStreamReceive((uint32)(self0), (uint64)(maxResults0), &result)
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]incoming-datagram-stream.receive
//go:noescape
func wasmimport_IncomingDatagramStreamReceive(self0 uint32, maxResults0 uint64, result *cm.OKResult[cm.List[IncomingDatagram], network.ErrorCode])
// Subscribe represents the imported method "subscribe".
//
// 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.
//
// subscribe: func() -> pollable
//
//go:nosplit
func (self IncomingDatagramStream) Subscribe() (result poll.Pollable) {
self0 := cm.Reinterpret[uint32](self)
result0 := wasmimport_IncomingDatagramStreamSubscribe((uint32)(self0))
result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]incoming-datagram-stream.subscribe
//go:noescape
func wasmimport_IncomingDatagramStreamSubscribe(self0 uint32) (result0 uint32)
// OutgoingDatagramStream represents the imported resource "wasi:sockets/udp@0.2.0#outgoing-datagram-stream".
//
// resource outgoing-datagram-stream
type OutgoingDatagramStream cm.Resource
// ResourceDrop represents the imported resource-drop for resource "outgoing-datagram-stream".
//
// Drops a resource handle.
//
//go:nosplit
func (self OutgoingDatagramStream) ResourceDrop() {
self0 := cm.Reinterpret[uint32](self)
wasmimport_OutgoingDatagramStreamResourceDrop((uint32)(self0))
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [resource-drop]outgoing-datagram-stream
//go:noescape
func wasmimport_OutgoingDatagramStreamResourceDrop(self0 uint32)
// CheckSend represents the imported method "check-send".
//
// 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`.
//
// check-send: func() -> result<u64, error-code>
//
//go:nosplit
func (self OutgoingDatagramStream) CheckSend() (result cm.OKResult[uint64, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
wasmimport_OutgoingDatagramStreamCheckSend((uint32)(self0), &result)
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]outgoing-datagram-stream.check-send
//go:noescape
func wasmimport_OutgoingDatagramStreamCheckSend(self0 uint32, result *cm.OKResult[uint64, network.ErrorCode])
// Send represents the imported method "send".
//
// 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>
//
// send: func(datagrams: list<outgoing-datagram>) -> result<u64, error-code>
//
//go:nosplit
func (self OutgoingDatagramStream) Send(datagrams cm.List[OutgoingDatagram]) (result cm.OKResult[uint64, network.ErrorCode]) {
self0 := cm.Reinterpret[uint32](self)
datagrams0, datagrams1 := cm.LowerList(datagrams)
wasmimport_OutgoingDatagramStreamSend((uint32)(self0), (*OutgoingDatagram)(datagrams0), (uint32)(datagrams1), &result)
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]outgoing-datagram-stream.send
//go:noescape
func wasmimport_OutgoingDatagramStreamSend(self0 uint32, datagrams0 *OutgoingDatagram, datagrams1 uint32, result *cm.OKResult[uint64, network.ErrorCode])
// Subscribe represents the imported method "subscribe".
//
// 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.
//
// subscribe: func() -> pollable
//
//go:nosplit
func (self OutgoingDatagramStream) Subscribe() (result poll.Pollable) {
self0 := cm.Reinterpret[uint32](self)
result0 := wasmimport_OutgoingDatagramStreamSubscribe((uint32)(self0))
result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
return
}
//go:wasmimport wasi:sockets/udp@0.2.0 [method]outgoing-datagram-stream.subscribe
//go:noescape
func wasmimport_OutgoingDatagramStreamSubscribe(self0 uint32) (result0 uint32)
src/os/dir_test.go
+1 -1
View File
@@ -1,4 +1,4 @@
//go:build darwin || (linux && !baremetal && !js && !wasip1 && !386 && !arm)
//go:build darwin || (linux && !baremetal && !js && !wasip1 && !wasip2 && !386 && !arm)
package os_test
src/os/dir_unix.go
+1 -1
View File
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
//go:build linux && !baremetal && !wasip1 && !wasm_unknown
//go:build linux && !baremetal && !wasip1 && !wasip2 && !wasm_unknown
package os
src/os/dir_wasip1.go → src/os/dir_wasi.go
+1 -1
View File
@@ -6,7 +6,7 @@
// fairly similar: we use fdopendir, fdclosedir, and readdir from wasi-libc in
// a similar way that the darwin code uses functions from libc.
//go:build wasip1
//go:build wasip1 || wasip2
package os
src/os/dirent_linux.go
+1 -1
View File
@@ -1,4 +1,4 @@
//go:build !baremetal && !js && !wasip1 && !wasm_unknown
//go:build !baremetal && !js && !wasip1 && !wasip2 && !wasm_unknown
// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
src/os/env_unix_test.go
+1 -1
View File
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
//go:build darwin || linux || wasip1
//go:build darwin || linux || wasip1 || wasip2
package os_test
src/os/exec_posix.go
+1 -1
View File
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || wasip1 || windows
//go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris || wasip1 || wasip2 || windows
package os
src/os/file_other.go
+1 -1
View File
@@ -1,4 +1,4 @@
//go:build baremetal || (tinygo.wasm && !wasip1)
//go:build baremetal || (tinygo.wasm && !wasip1 && !wasip2)
package os
src/os/file_unix.go
+1 -1
View File
@@ -1,4 +1,4 @@
//go:build darwin || (linux && !baremetal && !wasm_unknown) || wasip1
//go:build darwin || (linux && !baremetal && !wasm_unknown) || wasip1 || wasip2
// target wasi sets GOOS=linux and thus the +linux build tag,
// even though it doesn't show up in "tinygo info target -wasi"
src/os/getpagesize_test.go
+1 -1
View File
@@ -1,4 +1,4 @@
//go:build windows || darwin || (linux && !baremetal) || wasip1
//go:build windows || darwin || (linux && !baremetal) || wasip1 || wasip2
package os_test
src/os/os_anyos_test.go
+3 -3
View File
@@ -1,4 +1,4 @@
//go:build windows || darwin || (linux && !baremetal) || wasip1
//go:build windows || darwin || (linux && !baremetal) || wasip1 || wasip2
package os_test
@@ -275,7 +275,7 @@ func TestDirFS(t *testing.T) {
t.Log("TODO: implement Readdir for Windows")
return
}
if runtime.GOOS == "wasip1" {
if runtime.GOOS == "wasip1" || runtime.GOOS == "wasip2" {
t.Log("TODO: allow foo/bar/. as synonym for path foo/bar on wasi?")
return
}
@@ -296,7 +296,7 @@ func TestDirFSPathsValid(t *testing.T) {
t.Log("skipping on Windows")
return
}
if runtime.GOOS == "wasip1" {
if runtime.GOOS == "wasip1" || runtime.GOOS == "wasip2" {
t.Log("skipping on wasi because it fails on wasi on windows")
return
}
src/os/os_chmod_test.go
+1 -1
View File
@@ -1,4 +1,4 @@
//go:build !baremetal && !js && !wasip1
//go:build !baremetal && !js && !wasip1 && !wasip2
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
src/os/os_hardlink_test.go
+1 -1
View File
@@ -1,4 +1,4 @@
//go:build !windows && !baremetal && !js && !wasi && !wasip1 && !wasm_unknown
//go:build !windows && !baremetal && !js && !wasip1 && !wasm_unknown
// Copyright 2024 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
src/os/os_symlink_test.go
+1 -1
View File
@@ -1,4 +1,4 @@
//go:build !windows && !baremetal && !js && !wasip1
//go:build !windows && !baremetal && !js && !wasip1 && !wasip2
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
src/os/pipe_test.go
+1 -1
View File
@@ -1,4 +1,4 @@
//go:build windows || darwin || (linux && !baremetal && !wasi)
//go:build windows || darwin || (linux && !baremetal && !wasip1 && !wasip2)
// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
src/os/read_test.go
+1 -1
View File
@@ -1,4 +1,4 @@
//go:build !baremetal && !js && !wasip1
//go:build !baremetal && !js && !wasip1 && !wasip2
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
src/os/removeall_noat.go
+1 -1
View File
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
//go:build !baremetal && !js && !wasip1 && !wasm_unknown
//go:build !baremetal && !js && !wasip1 && !wasip2 && !wasm_unknown
package os
src/os/removeall_other.go
+1 -1
View File
@@ -1,4 +1,4 @@
//go:build baremetal || js || wasi || wasip1 || wasm_unknown
//go:build baremetal || js || wasip1 || wasip2 || wasm_unknown
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
src/os/removeall_test.go
+1 -1
View File
@@ -1,4 +1,4 @@
//go:build darwin || (linux && !baremetal && !js && !wasi)
//go:build darwin || (linux && !baremetal && !js && !wasip1 && !wasip2)
// TODO: implement ReadDir on windows
src/os/seek_unix_bad.go
+1 -1
View File
@@ -1,4 +1,4 @@
//go:build (linux && !baremetal && 386) || (linux && !baremetal && arm && !wasi)
//go:build (linux && !baremetal && 386) || (linux && !baremetal && arm && !wasip1 && !wasip2)
package os
src/os/stat_linuxlike.go
+1 -1
View File
@@ -1,4 +1,4 @@
//go:build (linux && !baremetal && !wasm_unknown) || wasip1
//go:build (linux && !baremetal && !wasm_unknown) || wasip1 || wasip2
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
src/os/stat_other.go
+1 -1
View File
@@ -1,4 +1,4 @@
//go:build baremetal || (tinygo.wasm && !wasip1)
//go:build baremetal || (tinygo.wasm && !wasip1 && !wasip2)
// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style

Some files were not shown because too many files have changed in this diff Show More