wasmer_c_api/wasm_c_api/wasi/
mod.rs

1//! Unofficial API for WASI integrating with the standard Wasm C API.
2//!
3//! This API will be superseded by a standard WASI API when/if such a standard is created.
4
5pub use super::unstable::wasi::wasi_get_unordered_imports;
6use super::{
7    externals::{wasm_extern_t, wasm_extern_vec_t, wasm_func_t, wasm_memory_t},
8    instance::wasm_instance_t,
9    module::wasm_module_t,
10    store::{StoreRef, wasm_store_t},
11    types::wasm_byte_vec_t,
12};
13use crate::error::update_last_error;
14use std::convert::TryFrom;
15use std::ffi::CStr;
16use std::os::raw::c_char;
17use std::slice;
18use std::sync::Arc;
19#[cfg(feature = "webc_runner")]
20use wasmer_api::{AsStoreMut, Imports, Module};
21use wasmer_wasix::{
22    Pipe, PluggableRuntime, WasiEnv, WasiEnvBuilder, WasiFunctionEnv, WasiVersion,
23    default_fs_backing, get_wasi_version,
24    runtime::task_manager::{block_on, tokio::TokioTaskManager},
25    virtual_fs::AsyncReadExt,
26    virtual_fs::VirtualFile,
27};
28
29#[derive(Debug)]
30#[allow(non_camel_case_types)]
31pub struct wasi_config_t {
32    inherit_stdout: bool,
33    inherit_stderr: bool,
34    inherit_stdin: bool,
35    builder: WasiEnvBuilder,
36    runtime: Option<tokio::runtime::Runtime>,
37}
38
39#[unsafe(no_mangle)]
40pub unsafe extern "C" fn wasi_config_new(
41    program_name: *const c_char,
42) -> Option<Box<wasi_config_t>> {
43    debug_assert!(!program_name.is_null());
44
45    let name_c_str = unsafe { CStr::from_ptr(program_name) };
46    let prog_name = c_try!(name_c_str.to_str());
47
48    let runtime = tokio::runtime::Builder::new_multi_thread()
49        .enable_all()
50        .build()
51        .unwrap();
52    let _guard = runtime.enter();
53
54    Some(Box::new(wasi_config_t {
55        inherit_stdout: true,
56        inherit_stderr: true,
57        inherit_stdin: true,
58        builder: WasiEnv::builder(prog_name).fs(default_fs_backing()),
59        runtime: Some(runtime),
60    }))
61}
62
63#[unsafe(no_mangle)]
64pub unsafe extern "C" fn wasi_config_env(
65    config: &mut wasi_config_t,
66    key: *const c_char,
67    value: *const c_char,
68) {
69    debug_assert!(!key.is_null());
70    debug_assert!(!value.is_null());
71
72    let key_cstr = unsafe { CStr::from_ptr(key) };
73    let key_bytes = key_cstr.to_bytes();
74    let value_cstr = unsafe { CStr::from_ptr(value) };
75    let value_bytes = value_cstr.to_bytes();
76
77    config.builder.add_env(key_bytes, value_bytes);
78}
79
80#[unsafe(no_mangle)]
81pub unsafe extern "C" fn wasi_config_arg(config: &mut wasi_config_t, arg: *const c_char) {
82    debug_assert!(!arg.is_null());
83
84    let arg_cstr = unsafe { CStr::from_ptr(arg) };
85    let arg_bytes = arg_cstr.to_bytes();
86
87    config.builder.add_arg(arg_bytes);
88}
89
90#[unsafe(no_mangle)]
91pub unsafe extern "C" fn wasi_config_preopen_dir(
92    config: &mut wasi_config_t,
93    dir: *const c_char,
94) -> bool {
95    let dir_cstr = unsafe { CStr::from_ptr(dir) };
96    let dir_bytes = dir_cstr.to_bytes();
97    let dir_str = match std::str::from_utf8(dir_bytes) {
98        Ok(dir_str) => dir_str,
99        Err(e) => {
100            update_last_error(e);
101            return false;
102        }
103    };
104
105    if let Err(e) = config.builder.add_preopen_dir(dir_str) {
106        update_last_error(e);
107        return false;
108    }
109
110    true
111}
112
113#[unsafe(no_mangle)]
114pub unsafe extern "C" fn wasi_config_mapdir(
115    config: &mut wasi_config_t,
116    alias: *const c_char,
117    dir: *const c_char,
118) -> bool {
119    let alias_cstr = unsafe { CStr::from_ptr(alias) };
120    let alias_bytes = alias_cstr.to_bytes();
121    let alias_str = match std::str::from_utf8(alias_bytes) {
122        Ok(alias_str) => alias_str,
123        Err(e) => {
124            update_last_error(e);
125            return false;
126        }
127    };
128
129    let dir_cstr = unsafe { CStr::from_ptr(dir) };
130    let dir_bytes = dir_cstr.to_bytes();
131    let dir_str = match std::str::from_utf8(dir_bytes) {
132        Ok(dir_str) => dir_str,
133        Err(e) => {
134            update_last_error(e);
135            return false;
136        }
137    };
138
139    if let Err(e) = config.builder.add_map_dir(alias_str, dir_str) {
140        update_last_error(e);
141        return false;
142    }
143
144    true
145}
146
147#[unsafe(no_mangle)]
148pub extern "C" fn wasi_config_capture_stdout(config: &mut wasi_config_t) {
149    config.inherit_stdout = false;
150}
151
152#[unsafe(no_mangle)]
153pub extern "C" fn wasi_config_inherit_stdout(config: &mut wasi_config_t) {
154    config.inherit_stdout = true;
155}
156
157#[unsafe(no_mangle)]
158pub extern "C" fn wasi_config_capture_stderr(config: &mut wasi_config_t) {
159    config.inherit_stderr = false;
160}
161
162#[unsafe(no_mangle)]
163pub extern "C" fn wasi_config_inherit_stderr(config: &mut wasi_config_t) {
164    config.inherit_stderr = true;
165}
166
167//#[unsafe(no_mangle)]
168//pub extern "C" fn wasi_config_capture_stdin(config: &mut wasi_config_t) {
169//    config.inherit_stdin = false;
170//}
171
172#[unsafe(no_mangle)]
173pub extern "C" fn wasi_config_inherit_stdin(config: &mut wasi_config_t) {
174    config.inherit_stdin = true;
175}
176
177#[repr(C)]
178pub struct wasi_filesystem_t {
179    ptr: *const c_char,
180    size: usize,
181}
182
183#[unsafe(no_mangle)]
184pub unsafe extern "C" fn wasi_filesystem_init_static_memory(
185    volume_bytes: Option<&wasm_byte_vec_t>,
186) -> Option<Box<wasi_filesystem_t>> {
187    let volume_bytes = volume_bytes.as_ref()?;
188    Some(Box::new(wasi_filesystem_t {
189        ptr: {
190            let ptr = unsafe { volume_bytes.data.as_ref()? } as *const _ as *const c_char;
191            if ptr.is_null() {
192                return None;
193            }
194            ptr
195        },
196        size: volume_bytes.size,
197    }))
198}
199
200#[unsafe(no_mangle)]
201pub unsafe extern "C" fn wasi_filesystem_delete(ptr: *mut wasi_filesystem_t) {
202    let _ = unsafe { Box::from_raw(ptr) };
203}
204
205/// Initializes the `imports` with an import object that links to
206/// the custom file system
207#[cfg(feature = "webc_runner")]
208#[unsafe(no_mangle)]
209pub unsafe extern "C" fn wasi_env_with_filesystem(
210    config: Box<wasi_config_t>,
211    store: Option<&mut wasm_store_t>,
212    module: Option<&wasm_module_t>,
213    fs: Option<&wasi_filesystem_t>,
214    imports: Option<&mut wasm_extern_vec_t>,
215    package: *const c_char,
216) -> Option<Box<wasi_env_t>> {
217    unsafe { wasi_env_with_filesystem_inner(config, store, module, fs, imports, package) }
218}
219
220#[cfg(feature = "webc_runner")]
221unsafe fn wasi_env_with_filesystem_inner(
222    config: Box<wasi_config_t>,
223    store: Option<&mut wasm_store_t>,
224    module: Option<&wasm_module_t>,
225    fs: Option<&wasi_filesystem_t>,
226    imports: Option<&mut wasm_extern_vec_t>,
227    package: *const c_char,
228) -> Option<Box<wasi_env_t>> {
229    let store = &mut store?.inner;
230    let fs = fs.as_ref()?;
231    let package_str = unsafe { CStr::from_ptr(package) };
232    let package = package_str.to_str().unwrap_or("");
233    let module = &module.as_ref()?.inner;
234    let imports = imports?;
235    let fs_bytes = unsafe { &*(fs.ptr as *const u8) };
236
237    let (wasi_env, import_object) = {
238        let mut store_mut = unsafe { store.store_mut() };
239        prepare_webc_env(
240            config,
241            &mut store_mut,
242            module,
243            fs_bytes, // cast wasi_filesystem_t.ptr as &'static [u8]
244            fs.size,
245            package,
246        )?
247    };
248
249    imports_set_buffer(store, module, import_object, imports)?;
250
251    Some(Box::new(wasi_env_t {
252        inner: wasi_env,
253        store: store.clone(),
254    }))
255}
256
257#[cfg(feature = "webc_runner")]
258fn prepare_webc_env(
259    mut config: Box<wasi_config_t>,
260    store: &mut impl AsStoreMut,
261    module: &Module,
262    bytes: &'static u8,
263    len: usize,
264    package_name: &str,
265) -> Option<(WasiFunctionEnv, Imports)> {
266    use virtual_fs::static_fs::StaticFileSystem;
267    use wasmer_wasix::virtual_fs::FileSystem;
268    use webc::v1::{FsEntryType, WebC};
269
270    let store_mut = store.as_store_mut();
271    let runtime = config.runtime.take();
272
273    let runtime = runtime.unwrap_or_else(|| {
274        tokio::runtime::Builder::new_multi_thread()
275            .enable_all()
276            .build()
277            .unwrap()
278    });
279
280    let handle = runtime.handle().clone();
281    let _guard = handle.enter();
282    let mut rt = PluggableRuntime::new(Arc::new(TokioTaskManager::new(runtime)));
283    rt.set_engine(store_mut.engine().clone());
284
285    let slice = unsafe { std::slice::from_raw_parts(bytes, len) };
286    let volumes = WebC::parse_volumes_from_fileblock(slice).ok()?;
287    let top_level_dirs = volumes
288        .into_iter()
289        .flat_map(|(_, volume)| {
290            volume
291                .header
292                .top_level
293                .iter()
294                .filter(|entry| entry.fs_type == FsEntryType::Dir)
295                .cloned()
296                .map(|e| e.text.to_string())
297                .collect::<Vec<_>>()
298                .into_iter()
299        })
300        .collect::<Vec<_>>();
301
302    let filesystem =
303        Arc::new(StaticFileSystem::init(slice, package_name)?) as Arc<dyn FileSystem + Send + Sync>;
304    let mut builder = config.builder.runtime(Arc::new(rt));
305
306    if !config.inherit_stdout {
307        builder.set_stdout(Box::new(Pipe::channel().0));
308    }
309
310    if !config.inherit_stderr {
311        builder.set_stderr(Box::new(Pipe::channel().0));
312    }
313
314    builder.set_fs(filesystem);
315
316    for f_name in top_level_dirs.iter() {
317        builder
318            .add_preopen_build(|p| p.directory(f_name).read(true).write(true).create(true))
319            .ok()?;
320    }
321    let env = builder.finalize(store).ok()?;
322
323    let import_object = env.import_object(store, module).ok()?;
324    Some((env, import_object))
325}
326
327#[allow(non_camel_case_types)]
328pub struct wasi_env_t {
329    /// cbindgen:ignore
330    pub(super) inner: WasiFunctionEnv,
331    pub(super) store: StoreRef,
332}
333
334/// Create a new WASI environment.
335///
336/// It take ownership over the `wasi_config_t`.
337#[unsafe(no_mangle)]
338pub unsafe extern "C" fn wasi_env_new(
339    store: Option<&mut wasm_store_t>,
340    mut config: Box<wasi_config_t>,
341) -> Option<Box<wasi_env_t>> {
342    let store = &mut store?.inner;
343    let mut store_mut = unsafe { store.store_mut() };
344
345    let runtime = config.runtime.take();
346
347    let runtime = runtime.unwrap_or_else(|| {
348        tokio::runtime::Builder::new_multi_thread()
349            .enable_all()
350            .build()
351            .unwrap()
352    });
353
354    let handle = runtime.handle().clone();
355    let _guard = handle.enter();
356    let mut rt = PluggableRuntime::new(Arc::new(TokioTaskManager::new(runtime)));
357    rt.set_engine(store_mut.engine().clone());
358
359    if !config.inherit_stdout {
360        config.builder.set_stdout(Box::new(Pipe::channel().0));
361    }
362
363    if !config.inherit_stderr {
364        config.builder.set_stderr(Box::new(Pipe::channel().0));
365    }
366
367    // TODO: impl capturer for stdin
368
369    let env = c_try!(
370        config
371            .builder
372            .runtime(Arc::new(rt))
373            .finalize(&mut store_mut)
374    );
375
376    Some(Box::new(wasi_env_t {
377        inner: env,
378        store: store.clone(),
379    }))
380}
381
382/// Delete a [`wasi_env_t`].
383#[unsafe(no_mangle)]
384pub extern "C" fn wasi_env_delete(state: Option<Box<wasi_env_t>>) {
385    if let Some(mut env) = state {
386        let mut store = unsafe { env.store.store_mut() };
387        env.inner.on_exit(&mut store, None);
388    }
389}
390
391/// Set the memory on a [`wasi_env_t`].
392// NOTE: Only here to not break the C API.
393// This was previosly supported, but is no longer possible due to WASIX changes.
394// Customizing memories should be done through the builder or the runtime.
395#[unsafe(no_mangle)]
396#[deprecated(since = "4.0.0")]
397pub unsafe extern "C" fn wasi_env_set_memory(_env: &mut wasi_env_t, _memory: &wasm_memory_t) {
398    panic!("wasmer_env_set_memory() is not supported");
399}
400
401#[unsafe(no_mangle)]
402pub unsafe extern "C" fn wasi_env_read_stdout(
403    env: &mut wasi_env_t,
404    buffer: *mut c_char,
405    buffer_len: usize,
406) -> isize {
407    let inner_buffer = unsafe { slice::from_raw_parts_mut(buffer as *mut _, buffer_len) };
408    let store = unsafe { env.store.store() };
409
410    let stdout = {
411        let data = env.inner.data(&store);
412        data.stdout()
413    };
414
415    if let Ok(mut stdout) = stdout {
416        if let Some(stdout) = stdout.as_mut() {
417            read_inner(stdout, inner_buffer)
418        } else {
419            update_last_error("could not find a file handle for `stdout`");
420            -1
421        }
422    } else {
423        update_last_error("could not find a file handle for `stdout`");
424        -1
425    }
426}
427
428#[unsafe(no_mangle)]
429pub unsafe extern "C" fn wasi_env_read_stderr(
430    env: &mut wasi_env_t,
431    buffer: *mut c_char,
432    buffer_len: usize,
433) -> isize {
434    let inner_buffer = unsafe { slice::from_raw_parts_mut(buffer as *mut _, buffer_len) };
435    let store = unsafe { env.store.store() };
436    let stderr = {
437        let data = env.inner.data(&store);
438        data.stderr()
439    };
440    if let Ok(mut stderr) = stderr {
441        if let Some(stderr) = stderr.as_mut() {
442            read_inner(stderr, inner_buffer)
443        } else {
444            update_last_error("could not find a file handle for `stderr`");
445            -1
446        }
447    } else {
448        update_last_error("could not find a file handle for `stderr`");
449        -1
450    }
451}
452
453fn read_inner(
454    wasi_file: &mut Box<dyn VirtualFile + Send + Sync + 'static>,
455    inner_buffer: &mut [u8],
456) -> isize {
457    block_on(async {
458        match wasi_file.read(inner_buffer).await {
459            Ok(a) => a as isize,
460            Err(err) => {
461                update_last_error(format!("failed to read wasi_file: {err}"));
462                -1
463            }
464        }
465    })
466}
467
468/// The version of WASI. This is determined by the imports namespace
469/// string.
470#[derive(Debug, Clone, Copy, PartialEq, Eq)]
471#[repr(C)]
472#[allow(non_camel_case_types)]
473pub enum wasi_version_t {
474    /// An invalid version.
475    INVALID_VERSION = -1,
476
477    /// Latest version.
478    ///
479    /// It's a “floating” version, i.e. it's an alias to the latest
480    /// version (for the moment, `Snapshot1`). Using this version is a
481    /// way to ensure that modules will run only if they come with the
482    /// latest WASI version (in case of security issues for instance),
483    /// by just updating the runtime.
484    ///
485    /// Note that this version is never returned by an API. It is
486    /// provided only by the user.
487    LATEST = 0,
488
489    /// `wasi_unstable`.
490    SNAPSHOT0 = 1,
491
492    /// `wasi_snapshot_preview1`.
493    SNAPSHOT1 = 2,
494
495    /// `wasix_32v1`.
496    WASIX32V1 = 3,
497
498    /// `wasix_64v1`.
499    WASIX64V1 = 4,
500}
501
502impl From<WasiVersion> for wasi_version_t {
503    fn from(other: WasiVersion) -> Self {
504        match other {
505            WasiVersion::Snapshot0 => wasi_version_t::SNAPSHOT0,
506            WasiVersion::Snapshot1 => wasi_version_t::SNAPSHOT1,
507            WasiVersion::Wasix32v1 => wasi_version_t::WASIX32V1,
508            WasiVersion::Wasix64v1 => wasi_version_t::WASIX64V1,
509            WasiVersion::Latest => wasi_version_t::LATEST,
510        }
511    }
512}
513
514impl TryFrom<wasi_version_t> for WasiVersion {
515    type Error = &'static str;
516
517    fn try_from(other: wasi_version_t) -> Result<Self, Self::Error> {
518        Ok(match other {
519            wasi_version_t::INVALID_VERSION => return Err("Invalid WASI version cannot be used"),
520            wasi_version_t::SNAPSHOT0 => WasiVersion::Snapshot0,
521            wasi_version_t::SNAPSHOT1 => WasiVersion::Snapshot1,
522            wasi_version_t::WASIX32V1 => WasiVersion::Wasix32v1,
523            wasi_version_t::WASIX64V1 => WasiVersion::Wasix64v1,
524            wasi_version_t::LATEST => WasiVersion::Latest,
525        })
526    }
527}
528
529#[unsafe(no_mangle)]
530pub unsafe extern "C" fn wasi_get_wasi_version(module: &wasm_module_t) -> wasi_version_t {
531    get_wasi_version(&module.inner, false)
532        .map(Into::into)
533        .unwrap_or(wasi_version_t::INVALID_VERSION)
534}
535
536/// Non-standard function to get the imports needed for the WASI
537/// implementation ordered as expected by the `wasm_module_t`.
538#[unsafe(no_mangle)]
539pub unsafe extern "C" fn wasi_get_imports(
540    _store: Option<&wasm_store_t>,
541    wasi_env: Option<&mut wasi_env_t>,
542    module: Option<&wasm_module_t>,
543    imports: &mut wasm_extern_vec_t,
544) -> bool {
545    unsafe { wasi_get_imports_inner(wasi_env, module, imports) }.is_some()
546}
547
548unsafe fn wasi_get_imports_inner(
549    wasi_env: Option<&mut wasi_env_t>,
550    module: Option<&wasm_module_t>,
551    imports: &mut wasm_extern_vec_t,
552) -> Option<()> {
553    let wasi_env = wasi_env?;
554    let store = &mut wasi_env.store;
555    let module = module?;
556
557    let mut import_object = {
558        let mut store_mut = unsafe { store.store_mut() };
559        c_try!(wasi_env.inner.import_object(&mut store_mut, &module.inner))
560    };
561
562    let shared_memory = module.inner.imports().memories().next().map(|a| *a.ty());
563
564    let spawn_type = match shared_memory {
565        Some(ty) => wasmer_wasix::runtime::SpawnType::CreateMemoryOfType(ty),
566        None => wasmer_wasix::runtime::SpawnType::CreateMemory,
567    };
568
569    let tasks = {
570        let store_ref = unsafe { store.store() };
571        wasi_env
572            .inner
573            .data(&store_ref)
574            .runtime
575            .task_manager()
576            .clone()
577    };
578    let memory = {
579        let mut store_mut = unsafe { store.store_mut() };
580        tasks.build_memory(&mut store_mut, &spawn_type).unwrap()
581    };
582
583    if let Some(memory) = memory {
584        import_object.define("env", "memory", memory);
585    }
586
587    imports_set_buffer(store, &module.inner, import_object, imports)?;
588
589    Some(())
590}
591
592pub(crate) fn imports_set_buffer(
593    store: &StoreRef,
594    module: &wasmer_api::Module,
595    import_object: wasmer_api::Imports,
596    imports: &mut wasm_extern_vec_t,
597) -> Option<()> {
598    imports.set_buffer(c_try!(
599        module
600            .imports()
601            .map(|import_type| {
602                let ext = import_object
603                    .get_export(import_type.module(), import_type.name())
604                    .ok_or_else(|| {
605                        format!(
606                            "Failed to resolve import \"{}\" \"{}\"",
607                            import_type.module(),
608                            import_type.name()
609                        )
610                    })?;
611
612                Ok(Some(Box::new(wasm_extern_t::new(store.clone(), ext))))
613            })
614            .collect::<Result<Vec<_>, String>>()
615    ));
616
617    Some(())
618}
619
620#[unsafe(no_mangle)]
621pub unsafe extern "C" fn wasi_env_initialize_instance(
622    wasi_env: &mut wasi_env_t,
623    store: &mut wasm_store_t,
624    instance: &mut wasm_instance_t,
625) -> bool {
626    let mut store_mut = unsafe { store.inner.store_mut() };
627    wasi_env
628        .inner
629        .initialize(&mut store_mut, instance.inner.clone())
630        .unwrap();
631    true
632}
633
634#[unsafe(no_mangle)]
635pub unsafe extern "C" fn wasi_get_start_function(
636    instance: &mut wasm_instance_t,
637) -> Option<Box<wasm_func_t>> {
638    let start = c_try!(instance.inner.exports.get_function("_start"));
639
640    Some(Box::new(wasm_func_t {
641        extern_: wasm_extern_t::new(instance.store.clone(), start.clone().into()),
642    }))
643}
644
645#[cfg(test)]
646mod tests {
647    #[cfg(not(target_os = "windows"))]
648    use inline_c::assert_c;
649    #[cfg(target_os = "windows")]
650    use wasmer_inline_c::assert_c;
651
652    #[allow(
653        unexpected_cfgs,
654        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
655    )]
656    #[cfg_attr(coverage_nightly, coverage(off))]
657    #[test]
658    fn test_wasi_get_wasi_version_snapshot0() {
659        (assert_c! {
660            #include "tests/wasmer.h"
661
662            int main() {
663                wasm_engine_t* engine = wasm_engine_new();
664                wasm_store_t* store = wasm_store_new(engine);
665                wasmer_funcenv_t* env = wasmer_funcenv_new(store, 0);
666
667                wasm_byte_vec_t wat;
668                wasmer_byte_vec_new_from_string(&wat, "(module (import \"wasi_unstable\" \"args_get\" (func (param i32 i32) (result i32))))");
669                wasm_byte_vec_t wasm;
670                wat2wasm(&wat, &wasm);
671
672                wasm_module_t* module = wasm_module_new(store, &wasm);
673                assert(module);
674
675                assert(wasi_get_wasi_version(module) == SNAPSHOT0);
676
677                wasm_module_delete(module);
678                wasm_byte_vec_delete(&wasm);
679                wasm_byte_vec_delete(&wat);
680                wasmer_funcenv_delete(env);
681                wasm_store_delete(store);
682                wasm_engine_delete(engine);
683
684                return 0;
685            }
686        })
687        .success();
688    }
689
690    #[allow(
691        unexpected_cfgs,
692        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
693    )]
694    #[cfg_attr(coverage_nightly, coverage(off))]
695    #[test]
696    fn test_wasi_get_wasi_version_snapshot1() {
697        (assert_c! {
698            #include "tests/wasmer.h"
699
700            int main() {
701                wasm_engine_t* engine = wasm_engine_new();
702                wasm_store_t* store = wasm_store_new(engine);
703                wasmer_funcenv_t* env = wasmer_funcenv_new(store, 0);
704
705                wasm_byte_vec_t wat;
706                wasmer_byte_vec_new_from_string(&wat, "(module (import \"wasi_snapshot_preview1\" \"args_get\" (func (param i32 i32) (result i32))))");
707                wasm_byte_vec_t wasm;
708                wat2wasm(&wat, &wasm);
709
710                wasm_module_t* module = wasm_module_new(store, &wasm);
711                assert(module);
712
713                assert(wasi_get_wasi_version(module) == SNAPSHOT1);
714
715                wasm_module_delete(module);
716                wasm_byte_vec_delete(&wasm);
717                wasm_byte_vec_delete(&wat);
718                wasmer_funcenv_delete(env);
719                wasm_store_delete(store);
720                wasm_engine_delete(engine);
721
722                return 0;
723            }
724        })
725        .success();
726    }
727
728    #[allow(
729        unexpected_cfgs,
730        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
731    )]
732    #[cfg_attr(coverage_nightly, coverage(off))]
733    #[test]
734    fn test_wasi_get_wasi_version_invalid() {
735        (assert_c! {
736            #include "tests/wasmer.h"
737
738            int main() {
739                wasm_engine_t* engine = wasm_engine_new();
740                wasm_store_t* store = wasm_store_new(engine);
741                wasmer_funcenv_t* env = wasmer_funcenv_new(store, 0);
742
743                wasm_byte_vec_t wat;
744                wasmer_byte_vec_new_from_string(&wat, "(module (import \"wasi_snpsht_prvw1\" \"args_get\" (func (param i32 i32) (result i32))))");
745                wasm_byte_vec_t wasm;
746                wat2wasm(&wat, &wasm);
747
748                wasm_module_t* module = wasm_module_new(store, &wasm);
749                assert(module);
750
751                assert(wasi_get_wasi_version(module) == INVALID_VERSION);
752
753                wasm_module_delete(module);
754                wasm_byte_vec_delete(&wasm);
755                wasm_byte_vec_delete(&wat);
756                wasmer_funcenv_delete(env);
757                wasm_store_delete(store);
758                wasm_engine_delete(engine);
759
760                return 0;
761            }
762        })
763        .success();
764    }
765}
wasmer_c_api/wasm_c_api/wasi/mod.rs

wasmer_c_api/wasm_c_api/wasi/
mod.rs
