/src/WasmEdge/include/host/wasi/wasifunc.h

Source (jump to first uncovered line)
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2019-2024 Second State INC

#pragma once

#include "host/wasi/wasibase.h"

#include <cstdint>

namespace WasmEdge {
namespace Host {

class WasiArgsGet : public Wasi<WasiArgsGet> {
public:
  WasiArgsGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t ArgvPtr,
                        uint32_t ArgvBufPtr);
};

class WasiArgsSizesGet : public Wasi<WasiArgsSizesGet> {
public:
  WasiArgsSizesGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame,
                        uint32_t /* Out */ ArgcPtr,
                        uint32_t /* Out */ ArgvBufSizePtr);
};

class WasiEnvironGet : public Wasi<WasiEnvironGet> {
public:
  WasiEnvironGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t EnvPtr,
                        uint32_t EnvBufPtr);
};

class WasiEnvironSizesGet : public Wasi<WasiEnvironSizesGet> {
public:
  WasiEnvironSizesGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame,
                        uint32_t /* Out */ EnvCntPtr,
                        uint32_t /* Out */ EnvBufSizePtr);
};

class WasiClockResGet : public Wasi<WasiClockResGet> {
public:
  WasiClockResGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t ClockId,
                        uint32_t /* Out */ ResolutionPtr);
};

class WasiClockTimeGet : public Wasi<WasiClockTimeGet> {
public:
  WasiClockTimeGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t ClockId,
                        uint64_t Precision, uint32_t /* Out */ TimePtr);
};

class WasiFdAdvise : public Wasi<WasiFdAdvise> {
public:
  WasiFdAdvise(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint64_t Offset, uint64_t Len, uint32_t Advice);
};

class WasiFdAllocate : public Wasi<WasiFdAllocate> {
public:
  WasiFdAllocate(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint64_t Offset, uint64_t Len);
};

class WasiFdClose : public Wasi<WasiFdClose> {
public:
  WasiFdClose(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd);
};

class WasiFdDatasync : public Wasi<WasiFdDatasync> {
public:
  WasiFdDatasync(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd);
};

class WasiFdFdstatGet : public Wasi<WasiFdFdstatGet> {
public:
  WasiFdFdstatGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t /* Out */ FdStatPtr);
};

class WasiFdFdstatSetFlags : public Wasi<WasiFdFdstatSetFlags> {
public:
  WasiFdFdstatSetFlags(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t FsFlags);
};

class WasiFdFdstatSetRights : public Wasi<WasiFdFdstatSetRights> {
public:
  WasiFdFdstatSetRights(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint64_t FsRightsBase, uint64_t FsRightsInheriting);
};

class WasiFdFilestatGet : public Wasi<WasiFdFilestatGet> {
public:
  WasiFdFilestatGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t /* Out */ FilestatPtr);
};

class WasiFdFilestatSetSize : public Wasi<WasiFdFilestatSetSize> {
public:
  WasiFdFilestatSetSize(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint64_t Size);
};

class WasiFdFilestatSetTimes : public Wasi<WasiFdFilestatSetTimes> {
public:
  WasiFdFilestatSetTimes(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint64_t ATim, uint64_t MTim, uint32_t FstFlags);
};

class WasiFdPread : public Wasi<WasiFdPread> {
public:
  WasiFdPread(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t IOVsPtr, uint32_t IOVsLen, uint64_t Offset,
                        uint32_t /* Out */ NReadPtr);
};

class WasiFdPrestatGet : public Wasi<WasiFdPrestatGet> {
public:
  WasiFdPrestatGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t /* Out */ PreStatPtr);
};

class WasiFdPrestatDirName : public Wasi<WasiFdPrestatDirName> {
public:
  WasiFdPrestatDirName(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t PathBufPtr, uint32_t PathLen);
};

class WasiFdPwrite : public Wasi<WasiFdPwrite> {
public:
  WasiFdPwrite(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t IOVSPtr, uint32_t IOVSLen, uint64_t Offset,
                        uint32_t /* Out */ NWrittenPtr);
};

class WasiFdRead : public Wasi<WasiFdRead> {
public:
  WasiFdRead(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t IOVSPtr, uint32_t IOVSLen,
                        uint32_t /* Out */ NReadPtr);
};

class WasiFdReadDir : public Wasi<WasiFdReadDir> {
public:
  WasiFdReadDir(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t BufPtr, uint32_t BufLen, uint64_t Cookie,
                        uint32_t /* Out */ NReadPtr);
};

class WasiFdRenumber : public Wasi<WasiFdRenumber> {
public:
  WasiFdRenumber(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        int32_t ToFd);
};

class WasiFdSeek : public Wasi<WasiFdSeek> {
public:
  WasiFdSeek(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<int32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                       int64_t Offset, uint32_t Whence,
                       uint32_t /* Out */ NewOffsetPtr);
};

class WasiFdSync : public Wasi<WasiFdSync> {
public:
  WasiFdSync(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd);
};

class WasiFdTell : public Wasi<WasiFdTell> {
public:
  WasiFdTell(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t /* Out */ OffsetPtr);
};

class WasiFdWrite : public Wasi<WasiFdWrite> {
public:
  WasiFdWrite(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t IOVSPtr, uint32_t IOVSLen,
                        uint32_t /* Out */ NWrittenPtr);
};

class WasiPathCreateDirectory : public Wasi<WasiPathCreateDirectory> {
public:
  WasiPathCreateDirectory(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t PathPtr, uint32_t PathLen);
};

class WasiPathFilestatGet : public Wasi<WasiPathFilestatGet> {
public:
  WasiPathFilestatGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t Flags, uint32_t PathPtr, uint32_t PathLen,
                        uint32_t /* Out */ FilestatPtr);
};

class WasiPathFilestatSetTimes : public Wasi<WasiPathFilestatSetTimes> {
public:
  WasiPathFilestatSetTimes(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t Flags, uint32_t PathPtr, uint32_t PathLen,
                        uint64_t ATim, uint64_t MTim, uint32_t FstFlags);
};

class WasiPathLink : public Wasi<WasiPathLink> {
public:
  WasiPathLink(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t OldFd,
                        uint32_t OldFlags, uint32_t OldPathPtr,
                        uint32_t OldPathLen, int32_t NewFd, uint32_t NewPathPtr,
                        uint32_t NewPathLen);
};

class WasiPathOpen : public Wasi<WasiPathOpen> {
public:
  WasiPathOpen(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t DirFd,
                        uint32_t DirFlags, uint32_t PathPtr, uint32_t PathLen,
                        uint32_t OFlags, uint64_t FsRightsBase,
                        uint64_t FsRightsInheriting, uint32_t FsFlags,
                        uint32_t /* Out */ FdPtr);
};

class WasiPathReadLink : public Wasi<WasiPathReadLink> {
public:
  WasiPathReadLink(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t PathPtr, uint32_t PathLen, uint32_t BufPtr,
                        uint32_t BufLen, uint32_t /* Out */ NReadPtr);
};

class WasiPathRemoveDirectory : public Wasi<WasiPathRemoveDirectory> {
public:
  WasiPathRemoveDirectory(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t PathPtr, uint32_t PathLen);
};

class WasiPathRename : public Wasi<WasiPathRename> {
public:
  WasiPathRename(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t OldPathPtr, uint32_t OldPathLen, int32_t NewFd,
                        uint32_t NewPathPtr, uint32_t NewPathLen);
};

class WasiPathSymlink : public Wasi<WasiPathSymlink> {
public:
  WasiPathSymlink(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t OldPathPtr,
                        uint32_t OldPathLen, int32_t Fd, uint32_t NewPathPtr,
                        uint32_t NewPathLen);
};

class WasiPathUnlinkFile : public Wasi<WasiPathUnlinkFile> {
public:
  WasiPathUnlinkFile(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t PathPtr, uint32_t PathLen);
};

template <WASI::TriggerType Trigger>
class WasiPollOneoff : public Wasi<WasiPollOneoff<Trigger>> {
public:
  WasiPollOneoff(WASI::Environ &HostEnv) : Wasi<WasiPollOneoff>(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t InPtr,
                        uint32_t OutPtr, uint32_t NSubscriptions,
                        uint32_t /* Out */ NEventsPtr);
};

class WasiProcExit : public Wasi<WasiProcExit> {
public:
  WasiProcExit(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<void> body(const Runtime::CallingFrame &Frame, uint32_t Status);
};

class WasiProcRaise : public Wasi<WasiProcRaise> {
public:
  WasiProcRaise(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t Signal);
};

class WasiSchedYield : public Wasi<WasiSchedYield> {
public:
  WasiSchedYield(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame);
};

class WasiRandomGet : public Wasi<WasiRandomGet> {
public:
  WasiRandomGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t BufPtr,
                        uint32_t BufLen);
};

class WasiSockOpenV1 : public Wasi<WasiSockOpenV1> {
public:
  WasiSockOpenV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame,
                        uint32_t AddressFamily, uint32_t SockType,
                        uint32_t /* Out */ RoFdPtr);
};

class WasiSockBindV1 : public Wasi<WasiSockBindV1> {
public:
  WasiSockBindV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t AddressPtr, uint32_t Port);
};

class WasiSockListenV1 : public Wasi<WasiSockListenV1> {
public:
  WasiSockListenV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        int32_t Backlog);
};

class WasiSockAcceptV1 : public Wasi<WasiSockAcceptV1> {
public:
  WasiSockAcceptV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t /* Out */ RoFdPtr);
};

class WasiSockConnectV1 : public Wasi<WasiSockConnectV1> {
public:
  WasiSockConnectV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t AddressPtr, uint32_t Port);
};

class WasiSockRecvV1 : public Wasi<WasiSockRecvV1> {
public:
  WasiSockRecvV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t RiDataPtr, uint32_t RiDataLen,
                        uint32_t RiFlags, uint32_t /* Out */ RoDataLenPtr,
                        uint32_t /* Out */ RoFlagsPtr);
};

class WasiSockRecvFromV1 : public Wasi<WasiSockRecvFromV1> {
public:
  WasiSockRecvFromV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t RiDataPtr, uint32_t RiDataLen,
                        uint32_t AddressPtr, uint32_t RiFlags,
                        uint32_t /* Out */ RoDataLenPtr,
                        uint32_t /* Out */ RoFlagsPtr);
};

class WasiSockSendV1 : public Wasi<WasiSockSendV1> {
public:
  WasiSockSendV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t SiDataPtr, uint32_t SiDataLen,
                        uint32_t SiFlags, uint32_t /* Out */ SoDataLenPtr);
};

class WasiSockSendToV1 : public Wasi<WasiSockSendToV1> {
public:
  WasiSockSendToV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t SiDataPtr, uint32_t SiDataLen,
                        uint32_t AddressPtr, int32_t Port, uint32_t SiFlags,
                        uint32_t /* Out */ SoDataLenPtr);
};

class WasiSockShutdown : public Wasi<WasiSockShutdown> {
public:
  WasiSockShutdown(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t SdFlags);
};

class WasiSockGetOpt : public Wasi<WasiSockGetOpt> {
public:
  WasiSockGetOpt(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t SockOptLevel, uint32_t SockOptName,
                        uint32_t FlagPtr, uint32_t FlagSizePtr);
};

class WasiSockSetOpt : public Wasi<WasiSockSetOpt> {
public:
  WasiSockSetOpt(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t SockOptLevel, uint32_t SockOptName,
                        uint32_t FlagPtr, uint32_t FlagSizePtr);
};

class WasiSockGetLocalAddrV1 : public Wasi<WasiSockGetLocalAddrV1> {
public:
  WasiSockGetLocalAddrV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t AddressPtr, uint32_t AddressTypePtr,
                        uint32_t PortPtr);
};

class WasiSockGetPeerAddrV1 : public Wasi<WasiSockGetPeerAddrV1> {
public:
  WasiSockGetPeerAddrV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t AddressPtr, uint32_t AddressTypePtr,
                        uint32_t PortPtr);
};

class WasiSockGetAddrinfo : public Wasi<WasiSockGetAddrinfo> {
public:
  WasiSockGetAddrinfo(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t NodePtr,
                        uint32_t NodeLen, uint32_t ServicePtr,
                        uint32_t ServiceLen, uint32_t HintsPtr, uint32_t ResPtr,
                        uint32_t MaxResLength, uint32_t ResLengthPtr);
};

class WasiSockOpenV2 : public Wasi<WasiSockOpenV2> {
public:
  WasiSockOpenV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame,
                        uint32_t AddressFamily, uint32_t SockType,
                        uint32_t /* Out */ RoFdPtr);
};

class WasiSockBindV2 : public Wasi<WasiSockBindV2> {
public:
  WasiSockBindV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t AddressPtr, uint32_t Port);
};

class WasiSockListenV2 : public Wasi<WasiSockListenV2> {
public:
  WasiSockListenV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        int32_t Backlog);
};

class WasiSockAcceptV2 : public Wasi<WasiSockAcceptV2> {
public:
  WasiSockAcceptV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t FsFlags, uint32_t /* Out */ RoFdPtr);
};

class WasiSockConnectV2 : public Wasi<WasiSockConnectV2> {
public:
  WasiSockConnectV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t AddressPtr, uint32_t Port);
};

class WasiSockRecvV2 : public Wasi<WasiSockRecvV2> {
public:
  WasiSockRecvV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t RiDataPtr, uint32_t RiDataLen,
                        uint32_t RiFlags, uint32_t /* Out */ RoDataLenPtr,
                        uint32_t /* Out */ RoFlagsPtr);
};

class WasiSockRecvFromV2 : public Wasi<WasiSockRecvFromV2> {
public:
  WasiSockRecvFromV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t RiDataPtr, uint32_t RiDataLen,
                        uint32_t AddressPtr, uint32_t RiFlags,
                        uint32_t /* Out */ PortPtr,
                        uint32_t /* Out */ RoDataLenPtr,
                        uint32_t /* Out */ RoFlagsPtr);
};

class WasiSockSendV2 : public Wasi<WasiSockSendV2> {
public:
  WasiSockSendV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t SiDataPtr, uint32_t SiDataLen,
                        uint32_t SiFlags, uint32_t /* Out */ SoDataLenPtr);
};

class WasiSockSendToV2 : public Wasi<WasiSockSendToV2> {
public:
  WasiSockSendToV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t SiDataPtr, uint32_t SiDataLen,
                        uint32_t AddressPtr, int32_t Port, uint32_t SiFlags,
                        uint32_t /* Out */ SoDataLenPtr);
};

class WasiSockGetLocalAddrV2 : public Wasi<WasiSockGetLocalAddrV2> {
public:
  WasiSockGetLocalAddrV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t AddressPtr, uint32_t PortPtr);
};

class WasiSockGetPeerAddrV2 : public Wasi<WasiSockGetPeerAddrV2> {
public:
  WasiSockGetPeerAddrV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}

  Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
                        uint32_t AddressPtr, uint32_t PortPtr);
};

} // namespace Host
} // namespace WasmEdge

Coverage Report

Created: 2025-07-01 06:18

Line	Count	Source (jump to first uncovered line)
1		// SPDX-License-Identifier: Apache-2.0
2		// SPDX-FileCopyrightText: 2019-2024 Second State INC
3
4		#pragma once
5
6		#include "host/wasi/wasibase.h"
7
8		#include <cstdint>
9
10		namespace WasmEdge {
11		namespace Host {
12
13		class WasiArgsGet : public Wasi<WasiArgsGet> {
14		public:
15	0	WasiArgsGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
16
17		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t ArgvPtr,
18		uint32_t ArgvBufPtr);
19		};
20
21		class WasiArgsSizesGet : public Wasi<WasiArgsSizesGet> {
22		public:
23	0	WasiArgsSizesGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
24
25		Expect<uint32_t> body(const Runtime::CallingFrame &Frame,
26		uint32_t /* Out */ ArgcPtr,
27		uint32_t /* Out */ ArgvBufSizePtr);
28		};
29
30		class WasiEnvironGet : public Wasi<WasiEnvironGet> {
31		public:
32	0	WasiEnvironGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
33
34		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t EnvPtr,
35		uint32_t EnvBufPtr);
36		};
37
38		class WasiEnvironSizesGet : public Wasi<WasiEnvironSizesGet> {
39		public:
40	0	WasiEnvironSizesGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
41
42		Expect<uint32_t> body(const Runtime::CallingFrame &Frame,
43		uint32_t /* Out */ EnvCntPtr,
44		uint32_t /* Out */ EnvBufSizePtr);
45		};
46
47		class WasiClockResGet : public Wasi<WasiClockResGet> {
48		public:
49	0	WasiClockResGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
50
51		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t ClockId,
52		uint32_t /* Out */ ResolutionPtr);
53		};
54
55		class WasiClockTimeGet : public Wasi<WasiClockTimeGet> {
56		public:
57	0	WasiClockTimeGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
58
59		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t ClockId,
60		uint64_t Precision, uint32_t /* Out */ TimePtr);
61		};
62
63		class WasiFdAdvise : public Wasi<WasiFdAdvise> {
64		public:
65	0	WasiFdAdvise(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
66
67		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
68		uint64_t Offset, uint64_t Len, uint32_t Advice);
69		};
70
71		class WasiFdAllocate : public Wasi<WasiFdAllocate> {
72		public:
73	0	WasiFdAllocate(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
74
75		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
76		uint64_t Offset, uint64_t Len);
77		};
78
79		class WasiFdClose : public Wasi<WasiFdClose> {
80		public:
81	0	WasiFdClose(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
82
83		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd);
84		};
85
86		class WasiFdDatasync : public Wasi<WasiFdDatasync> {
87		public:
88	0	WasiFdDatasync(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
89
90		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd);
91		};
92
93		class WasiFdFdstatGet : public Wasi<WasiFdFdstatGet> {
94		public:
95	0	WasiFdFdstatGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
96
97		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
98		uint32_t /* Out */ FdStatPtr);
99		};
100
101		class WasiFdFdstatSetFlags : public Wasi<WasiFdFdstatSetFlags> {
102		public:
103	0	WasiFdFdstatSetFlags(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
104
105		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
106		uint32_t FsFlags);
107		};
108
109		class WasiFdFdstatSetRights : public Wasi<WasiFdFdstatSetRights> {
110		public:
111	0	WasiFdFdstatSetRights(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
112
113		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
114		uint64_t FsRightsBase, uint64_t FsRightsInheriting);
115		};
116
117		class WasiFdFilestatGet : public Wasi<WasiFdFilestatGet> {
118		public:
119	0	WasiFdFilestatGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
120
121		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
122		uint32_t /* Out */ FilestatPtr);
123		};
124
125		class WasiFdFilestatSetSize : public Wasi<WasiFdFilestatSetSize> {
126		public:
127	0	WasiFdFilestatSetSize(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
128
129		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
130		uint64_t Size);
131		};
132
133		class WasiFdFilestatSetTimes : public Wasi<WasiFdFilestatSetTimes> {
134		public:
135	0	WasiFdFilestatSetTimes(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
136
137		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
138		uint64_t ATim, uint64_t MTim, uint32_t FstFlags);
139		};
140
141		class WasiFdPread : public Wasi<WasiFdPread> {
142		public:
143	0	WasiFdPread(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
144
145		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
146		uint32_t IOVsPtr, uint32_t IOVsLen, uint64_t Offset,
147		uint32_t /* Out */ NReadPtr);
148		};
149
150		class WasiFdPrestatGet : public Wasi<WasiFdPrestatGet> {
151		public:
152	0	WasiFdPrestatGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
153
154		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
155		uint32_t /* Out */ PreStatPtr);
156		};
157
158		class WasiFdPrestatDirName : public Wasi<WasiFdPrestatDirName> {
159		public:
160	0	WasiFdPrestatDirName(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
161
162		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
163		uint32_t PathBufPtr, uint32_t PathLen);
164		};
165
166		class WasiFdPwrite : public Wasi<WasiFdPwrite> {
167		public:
168	0	WasiFdPwrite(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
169
170		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
171		uint32_t IOVSPtr, uint32_t IOVSLen, uint64_t Offset,
172		uint32_t /* Out */ NWrittenPtr);
173		};
174
175		class WasiFdRead : public Wasi<WasiFdRead> {
176		public:
177	0	WasiFdRead(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
178
179		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
180		uint32_t IOVSPtr, uint32_t IOVSLen,
181		uint32_t /* Out */ NReadPtr);
182		};
183
184		class WasiFdReadDir : public Wasi<WasiFdReadDir> {
185		public:
186	0	WasiFdReadDir(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
187
188		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
189		uint32_t BufPtr, uint32_t BufLen, uint64_t Cookie,
190		uint32_t /* Out */ NReadPtr);
191		};
192
193		class WasiFdRenumber : public Wasi<WasiFdRenumber> {
194		public:
195	0	WasiFdRenumber(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
196
197		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
198		int32_t ToFd);
199		};
200
201		class WasiFdSeek : public Wasi<WasiFdSeek> {
202		public:
203	0	WasiFdSeek(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
204
205		Expect<int32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
206		int64_t Offset, uint32_t Whence,
207		uint32_t /* Out */ NewOffsetPtr);
208		};
209
210		class WasiFdSync : public Wasi<WasiFdSync> {
211		public:
212	0	WasiFdSync(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
213
214		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd);
215		};
216
217		class WasiFdTell : public Wasi<WasiFdTell> {
218		public:
219	0	WasiFdTell(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
220
221		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
222		uint32_t /* Out */ OffsetPtr);
223		};
224
225		class WasiFdWrite : public Wasi<WasiFdWrite> {
226		public:
227	0	WasiFdWrite(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
228
229		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
230		uint32_t IOVSPtr, uint32_t IOVSLen,
231		uint32_t /* Out */ NWrittenPtr);
232		};
233
234		class WasiPathCreateDirectory : public Wasi<WasiPathCreateDirectory> {
235		public:
236	0	WasiPathCreateDirectory(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
237
238		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
239		uint32_t PathPtr, uint32_t PathLen);
240		};
241
242		class WasiPathFilestatGet : public Wasi<WasiPathFilestatGet> {
243		public:
244	0	WasiPathFilestatGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
245
246		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
247		uint32_t Flags, uint32_t PathPtr, uint32_t PathLen,
248		uint32_t /* Out */ FilestatPtr);
249		};
250
251		class WasiPathFilestatSetTimes : public Wasi<WasiPathFilestatSetTimes> {
252		public:
253	0	WasiPathFilestatSetTimes(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
254
255		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
256		uint32_t Flags, uint32_t PathPtr, uint32_t PathLen,
257		uint64_t ATim, uint64_t MTim, uint32_t FstFlags);
258		};
259
260		class WasiPathLink : public Wasi<WasiPathLink> {
261		public:
262	0	WasiPathLink(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
263
264		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t OldFd,
265		uint32_t OldFlags, uint32_t OldPathPtr,
266		uint32_t OldPathLen, int32_t NewFd, uint32_t NewPathPtr,
267		uint32_t NewPathLen);
268		};
269
270		class WasiPathOpen : public Wasi<WasiPathOpen> {
271		public:
272	0	WasiPathOpen(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
273
274		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t DirFd,
275		uint32_t DirFlags, uint32_t PathPtr, uint32_t PathLen,
276		uint32_t OFlags, uint64_t FsRightsBase,
277		uint64_t FsRightsInheriting, uint32_t FsFlags,
278		uint32_t /* Out */ FdPtr);
279		};
280
281		class WasiPathReadLink : public Wasi<WasiPathReadLink> {
282		public:
283	0	WasiPathReadLink(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
284
285		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
286		uint32_t PathPtr, uint32_t PathLen, uint32_t BufPtr,
287		uint32_t BufLen, uint32_t /* Out */ NReadPtr);
288		};
289
290		class WasiPathRemoveDirectory : public Wasi<WasiPathRemoveDirectory> {
291		public:
292	0	WasiPathRemoveDirectory(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
293
294		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
295		uint32_t PathPtr, uint32_t PathLen);
296		};
297
298		class WasiPathRename : public Wasi<WasiPathRename> {
299		public:
300	0	WasiPathRename(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
301
302		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
303		uint32_t OldPathPtr, uint32_t OldPathLen, int32_t NewFd,
304		uint32_t NewPathPtr, uint32_t NewPathLen);
305		};
306
307		class WasiPathSymlink : public Wasi<WasiPathSymlink> {
308		public:
309	0	WasiPathSymlink(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
310
311		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t OldPathPtr,
312		uint32_t OldPathLen, int32_t Fd, uint32_t NewPathPtr,
313		uint32_t NewPathLen);
314		};
315
316		class WasiPathUnlinkFile : public Wasi<WasiPathUnlinkFile> {
317		public:
318	0	WasiPathUnlinkFile(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
319
320		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
321		uint32_t PathPtr, uint32_t PathLen);
322		};
323
324		template <WASI::TriggerType Trigger>
325		class WasiPollOneoff : public Wasi<WasiPollOneoff<Trigger>> {
326		public:
327	0	WasiPollOneoff(WASI::Environ &HostEnv) : Wasi<WasiPollOneoff>(HostEnv) {} Unexecuted instantiation: WasmEdge::Host::WasiPollOneoff<(WasmEdge::Host::WASI::TriggerType)0>::WasiPollOneoff(WasmEdge::Host::WASI::Environ&) Unexecuted instantiation: WasmEdge::Host::WasiPollOneoff<(WasmEdge::Host::WASI::TriggerType)1>::WasiPollOneoff(WasmEdge::Host::WASI::Environ&)
328
329		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t InPtr,
330		uint32_t OutPtr, uint32_t NSubscriptions,
331		uint32_t /* Out */ NEventsPtr);
332		};
333
334		class WasiProcExit : public Wasi<WasiProcExit> {
335		public:
336	0	WasiProcExit(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
337
338		Expect<void> body(const Runtime::CallingFrame &Frame, uint32_t Status);
339		};
340
341		class WasiProcRaise : public Wasi<WasiProcRaise> {
342		public:
343	0	WasiProcRaise(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
344
345		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t Signal);
346		};
347
348		class WasiSchedYield : public Wasi<WasiSchedYield> {
349		public:
350	0	WasiSchedYield(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
351
352		Expect<uint32_t> body(const Runtime::CallingFrame &Frame);
353		};
354
355		class WasiRandomGet : public Wasi<WasiRandomGet> {
356		public:
357	0	WasiRandomGet(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
358
359		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t BufPtr,
360		uint32_t BufLen);
361		};
362
363		class WasiSockOpenV1 : public Wasi<WasiSockOpenV1> {
364		public:
365	0	WasiSockOpenV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
366
367		Expect<uint32_t> body(const Runtime::CallingFrame &Frame,
368		uint32_t AddressFamily, uint32_t SockType,
369		uint32_t /* Out */ RoFdPtr);
370		};
371
372		class WasiSockBindV1 : public Wasi<WasiSockBindV1> {
373		public:
374	0	WasiSockBindV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
375
376		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
377		uint32_t AddressPtr, uint32_t Port);
378		};
379
380		class WasiSockListenV1 : public Wasi<WasiSockListenV1> {
381		public:
382	0	WasiSockListenV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
383
384		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
385		int32_t Backlog);
386		};
387
388		class WasiSockAcceptV1 : public Wasi<WasiSockAcceptV1> {
389		public:
390	0	WasiSockAcceptV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
391
392		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
393		uint32_t /* Out */ RoFdPtr);
394		};
395
396		class WasiSockConnectV1 : public Wasi<WasiSockConnectV1> {
397		public:
398	0	WasiSockConnectV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
399
400		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
401		uint32_t AddressPtr, uint32_t Port);
402		};
403
404		class WasiSockRecvV1 : public Wasi<WasiSockRecvV1> {
405		public:
406	0	WasiSockRecvV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
407
408		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
409		uint32_t RiDataPtr, uint32_t RiDataLen,
410		uint32_t RiFlags, uint32_t /* Out */ RoDataLenPtr,
411		uint32_t /* Out */ RoFlagsPtr);
412		};
413
414		class WasiSockRecvFromV1 : public Wasi<WasiSockRecvFromV1> {
415		public:
416	0	WasiSockRecvFromV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
417
418		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
419		uint32_t RiDataPtr, uint32_t RiDataLen,
420		uint32_t AddressPtr, uint32_t RiFlags,
421		uint32_t /* Out */ RoDataLenPtr,
422		uint32_t /* Out */ RoFlagsPtr);
423		};
424
425		class WasiSockSendV1 : public Wasi<WasiSockSendV1> {
426		public:
427	0	WasiSockSendV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
428
429		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
430		uint32_t SiDataPtr, uint32_t SiDataLen,
431		uint32_t SiFlags, uint32_t /* Out */ SoDataLenPtr);
432		};
433
434		class WasiSockSendToV1 : public Wasi<WasiSockSendToV1> {
435		public:
436	0	WasiSockSendToV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
437
438		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
439		uint32_t SiDataPtr, uint32_t SiDataLen,
440		uint32_t AddressPtr, int32_t Port, uint32_t SiFlags,
441		uint32_t /* Out */ SoDataLenPtr);
442		};
443
444		class WasiSockShutdown : public Wasi<WasiSockShutdown> {
445		public:
446	0	WasiSockShutdown(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
447
448		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
449		uint32_t SdFlags);
450		};
451
452		class WasiSockGetOpt : public Wasi<WasiSockGetOpt> {
453		public:
454	0	WasiSockGetOpt(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
455
456		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
457		uint32_t SockOptLevel, uint32_t SockOptName,
458		uint32_t FlagPtr, uint32_t FlagSizePtr);
459		};
460
461		class WasiSockSetOpt : public Wasi<WasiSockSetOpt> {
462		public:
463	0	WasiSockSetOpt(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
464
465		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
466		uint32_t SockOptLevel, uint32_t SockOptName,
467		uint32_t FlagPtr, uint32_t FlagSizePtr);
468		};
469
470		class WasiSockGetLocalAddrV1 : public Wasi<WasiSockGetLocalAddrV1> {
471		public:
472	0	WasiSockGetLocalAddrV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
473
474		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
475		uint32_t AddressPtr, uint32_t AddressTypePtr,
476		uint32_t PortPtr);
477		};
478
479		class WasiSockGetPeerAddrV1 : public Wasi<WasiSockGetPeerAddrV1> {
480		public:
481	0	WasiSockGetPeerAddrV1(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
482
483		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
484		uint32_t AddressPtr, uint32_t AddressTypePtr,
485		uint32_t PortPtr);
486		};
487
488		class WasiSockGetAddrinfo : public Wasi<WasiSockGetAddrinfo> {
489		public:
490	0	WasiSockGetAddrinfo(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
491
492		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, uint32_t NodePtr,
493		uint32_t NodeLen, uint32_t ServicePtr,
494		uint32_t ServiceLen, uint32_t HintsPtr, uint32_t ResPtr,
495		uint32_t MaxResLength, uint32_t ResLengthPtr);
496		};
497
498		class WasiSockOpenV2 : public Wasi<WasiSockOpenV2> {
499		public:
500	0	WasiSockOpenV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
501
502		Expect<uint32_t> body(const Runtime::CallingFrame &Frame,
503		uint32_t AddressFamily, uint32_t SockType,
504		uint32_t /* Out */ RoFdPtr);
505		};
506
507		class WasiSockBindV2 : public Wasi<WasiSockBindV2> {
508		public:
509	0	WasiSockBindV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
510
511		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
512		uint32_t AddressPtr, uint32_t Port);
513		};
514
515		class WasiSockListenV2 : public Wasi<WasiSockListenV2> {
516		public:
517	0	WasiSockListenV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
518
519		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
520		int32_t Backlog);
521		};
522
523		class WasiSockAcceptV2 : public Wasi<WasiSockAcceptV2> {
524		public:
525	0	WasiSockAcceptV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
526
527		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
528		uint32_t FsFlags, uint32_t /* Out */ RoFdPtr);
529		};
530
531		class WasiSockConnectV2 : public Wasi<WasiSockConnectV2> {
532		public:
533	0	WasiSockConnectV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
534
535		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
536		uint32_t AddressPtr, uint32_t Port);
537		};
538
539		class WasiSockRecvV2 : public Wasi<WasiSockRecvV2> {
540		public:
541	0	WasiSockRecvV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
542
543		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
544		uint32_t RiDataPtr, uint32_t RiDataLen,
545		uint32_t RiFlags, uint32_t /* Out */ RoDataLenPtr,
546		uint32_t /* Out */ RoFlagsPtr);
547		};
548
549		class WasiSockRecvFromV2 : public Wasi<WasiSockRecvFromV2> {
550		public:
551	0	WasiSockRecvFromV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
552
553		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
554		uint32_t RiDataPtr, uint32_t RiDataLen,
555		uint32_t AddressPtr, uint32_t RiFlags,
556		uint32_t /* Out */ PortPtr,
557		uint32_t /* Out */ RoDataLenPtr,
558		uint32_t /* Out */ RoFlagsPtr);
559		};
560
561		class WasiSockSendV2 : public Wasi<WasiSockSendV2> {
562		public:
563	0	WasiSockSendV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
564
565		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
566		uint32_t SiDataPtr, uint32_t SiDataLen,
567		uint32_t SiFlags, uint32_t /* Out */ SoDataLenPtr);
568		};
569
570		class WasiSockSendToV2 : public Wasi<WasiSockSendToV2> {
571		public:
572	0	WasiSockSendToV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
573
574		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
575		uint32_t SiDataPtr, uint32_t SiDataLen,
576		uint32_t AddressPtr, int32_t Port, uint32_t SiFlags,
577		uint32_t /* Out */ SoDataLenPtr);
578		};
579
580		class WasiSockGetLocalAddrV2 : public Wasi<WasiSockGetLocalAddrV2> {
581		public:
582	0	WasiSockGetLocalAddrV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
583
584		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
585		uint32_t AddressPtr, uint32_t PortPtr);
586		};
587
588		class WasiSockGetPeerAddrV2 : public Wasi<WasiSockGetPeerAddrV2> {
589		public:
590	0	WasiSockGetPeerAddrV2(WASI::Environ &HostEnv) : Wasi(HostEnv) {}
591
592		Expect<uint32_t> body(const Runtime::CallingFrame &Frame, int32_t Fd,
593		uint32_t AddressPtr, uint32_t PortPtr);
594		};
595
596		} // namespace Host
597		} // namespace WasmEdge