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::{InlineWaker, 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 webc::v1::{FsEntryType, WebC};
268
269    let store_mut = store.as_store_mut();
270    let runtime = config.runtime.take();
271
272    let runtime = runtime.unwrap_or_else(|| {
273        tokio::runtime::Builder::new_multi_thread()
274            .enable_all()
275            .build()
276            .unwrap()
277    });
278
279    let handle = runtime.handle().clone();
280    let _guard = handle.enter();
281    let mut rt = PluggableRuntime::new(Arc::new(TokioTaskManager::new(runtime)));
282    rt.set_engine(store_mut.engine().clone());
283
284    let slice = unsafe { std::slice::from_raw_parts(bytes, len) };
285    let volumes = WebC::parse_volumes_from_fileblock(slice).ok()?;
286    let top_level_dirs = volumes
287        .into_iter()
288        .flat_map(|(_, volume)| {
289            volume
290                .header
291                .top_level
292                .iter()
293                .filter(|entry| entry.fs_type == FsEntryType::Dir)
294                .cloned()
295                .map(|e| e.text.to_string())
296                .collect::<Vec<_>>()
297                .into_iter()
298        })
299        .collect::<Vec<_>>();
300
301    let filesystem = Box::new(StaticFileSystem::init(slice, package_name)?);
302    let mut builder = config.builder.runtime(Arc::new(rt));
303
304    if !config.inherit_stdout {
305        builder.set_stdout(Box::new(Pipe::channel().0));
306    }
307
308    if !config.inherit_stderr {
309        builder.set_stderr(Box::new(Pipe::channel().0));
310    }
311
312    builder.set_fs(filesystem);
313
314    for f_name in top_level_dirs.iter() {
315        builder
316            .add_preopen_build(|p| p.directory(f_name).read(true).write(true).create(true))
317            .ok()?;
318    }
319    let env = builder.finalize(store).ok()?;
320
321    let import_object = env.import_object(store, module).ok()?;
322    Some((env, import_object))
323}
324
325#[allow(non_camel_case_types)]
326pub struct wasi_env_t {
327    /// cbindgen:ignore
328    pub(super) inner: WasiFunctionEnv,
329    pub(super) store: StoreRef,
330}
331
332/// Create a new WASI environment.
333///
334/// It take ownership over the `wasi_config_t`.
335#[unsafe(no_mangle)]
336pub unsafe extern "C" fn wasi_env_new(
337    store: Option<&mut wasm_store_t>,
338    mut config: Box<wasi_config_t>,
339) -> Option<Box<wasi_env_t>> {
340    let store = &mut store?.inner;
341    let mut store_mut = unsafe { store.store_mut() };
342
343    let runtime = config.runtime.take();
344
345    let runtime = runtime.unwrap_or_else(|| {
346        tokio::runtime::Builder::new_multi_thread()
347            .enable_all()
348            .build()
349            .unwrap()
350    });
351
352    let handle = runtime.handle().clone();
353    let _guard = handle.enter();
354    let mut rt = PluggableRuntime::new(Arc::new(TokioTaskManager::new(runtime)));
355    rt.set_engine(store_mut.engine().clone());
356
357    if !config.inherit_stdout {
358        config.builder.set_stdout(Box::new(Pipe::channel().0));
359    }
360
361    if !config.inherit_stderr {
362        config.builder.set_stderr(Box::new(Pipe::channel().0));
363    }
364
365    // TODO: impl capturer for stdin
366
367    let env = c_try!(
368        config
369            .builder
370            .runtime(Arc::new(rt))
371            .finalize(&mut store_mut)
372    );
373
374    Some(Box::new(wasi_env_t {
375        inner: env,
376        store: store.clone(),
377    }))
378}
379
380/// Delete a [`wasi_env_t`].
381#[unsafe(no_mangle)]
382pub extern "C" fn wasi_env_delete(state: Option<Box<wasi_env_t>>) {
383    if let Some(mut env) = state {
384        let mut store = unsafe { env.store.store_mut() };
385        env.inner.on_exit(&mut store, None);
386    }
387}
388
389/// Set the memory on a [`wasi_env_t`].
390// NOTE: Only here to not break the C API.
391// This was previosly supported, but is no longer possible due to WASIX changes.
392// Customizing memories should be done through the builder or the runtime.
393#[unsafe(no_mangle)]
394#[deprecated(since = "4.0.0")]
395pub unsafe extern "C" fn wasi_env_set_memory(_env: &mut wasi_env_t, _memory: &wasm_memory_t) {
396    panic!("wasmer_env_set_memory() is not supported");
397}
398
399#[unsafe(no_mangle)]
400pub unsafe extern "C" fn wasi_env_read_stdout(
401    env: &mut wasi_env_t,
402    buffer: *mut c_char,
403    buffer_len: usize,
404) -> isize {
405    let inner_buffer = unsafe { slice::from_raw_parts_mut(buffer as *mut _, buffer_len) };
406    let store = unsafe { env.store.store() };
407
408    let stdout = {
409        let data = env.inner.data(&store);
410        data.stdout()
411    };
412
413    if let Ok(mut stdout) = stdout {
414        if let Some(stdout) = stdout.as_mut() {
415            read_inner(stdout, inner_buffer)
416        } else {
417            update_last_error("could not find a file handle for `stdout`");
418            -1
419        }
420    } else {
421        update_last_error("could not find a file handle for `stdout`");
422        -1
423    }
424}
425
426#[unsafe(no_mangle)]
427pub unsafe extern "C" fn wasi_env_read_stderr(
428    env: &mut wasi_env_t,
429    buffer: *mut c_char,
430    buffer_len: usize,
431) -> isize {
432    let inner_buffer = unsafe { slice::from_raw_parts_mut(buffer as *mut _, buffer_len) };
433    let store = unsafe { env.store.store() };
434    let stderr = {
435        let data = env.inner.data(&store);
436        data.stderr()
437    };
438    if let Ok(mut stderr) = stderr {
439        if let Some(stderr) = stderr.as_mut() {
440            read_inner(stderr, inner_buffer)
441        } else {
442            update_last_error("could not find a file handle for `stderr`");
443            -1
444        }
445    } else {
446        update_last_error("could not find a file handle for `stderr`");
447        -1
448    }
449}
450
451fn read_inner(
452    wasi_file: &mut Box<dyn VirtualFile + Send + Sync + 'static>,
453    inner_buffer: &mut [u8],
454) -> isize {
455    InlineWaker::block_on(async {
456        match wasi_file.read(inner_buffer).await {
457            Ok(a) => a as isize,
458            Err(err) => {
459                update_last_error(format!("failed to read wasi_file: {err}"));
460                -1
461            }
462        }
463    })
464}
465
466/// The version of WASI. This is determined by the imports namespace
467/// string.
468#[derive(Debug, Clone, Copy, PartialEq, Eq)]
469#[repr(C)]
470#[allow(non_camel_case_types)]
471pub enum wasi_version_t {
472    /// An invalid version.
473    INVALID_VERSION = -1,
474
475    /// Latest version.
476    ///
477    /// It's a “floating” version, i.e. it's an alias to the latest
478    /// version (for the moment, `Snapshot1`). Using this version is a
479    /// way to ensure that modules will run only if they come with the
480    /// latest WASI version (in case of security issues for instance),
481    /// by just updating the runtime.
482    ///
483    /// Note that this version is never returned by an API. It is
484    /// provided only by the user.
485    LATEST = 0,
486
487    /// `wasi_unstable`.
488    SNAPSHOT0 = 1,
489
490    /// `wasi_snapshot_preview1`.
491    SNAPSHOT1 = 2,
492
493    /// `wasix_32v1`.
494    WASIX32V1 = 3,
495
496    /// `wasix_64v1`.
497    WASIX64V1 = 4,
498}
499
500impl From<WasiVersion> for wasi_version_t {
501    fn from(other: WasiVersion) -> Self {
502        match other {
503            WasiVersion::Snapshot0 => wasi_version_t::SNAPSHOT0,
504            WasiVersion::Snapshot1 => wasi_version_t::SNAPSHOT1,
505            WasiVersion::Wasix32v1 => wasi_version_t::WASIX32V1,
506            WasiVersion::Wasix64v1 => wasi_version_t::WASIX64V1,
507            WasiVersion::Latest => wasi_version_t::LATEST,
508        }
509    }
510}
511
512impl TryFrom<wasi_version_t> for WasiVersion {
513    type Error = &'static str;
514
515    fn try_from(other: wasi_version_t) -> Result<Self, Self::Error> {
516        Ok(match other {
517            wasi_version_t::INVALID_VERSION => return Err("Invalid WASI version cannot be used"),
518            wasi_version_t::SNAPSHOT0 => WasiVersion::Snapshot0,
519            wasi_version_t::SNAPSHOT1 => WasiVersion::Snapshot1,
520            wasi_version_t::WASIX32V1 => WasiVersion::Wasix32v1,
521            wasi_version_t::WASIX64V1 => WasiVersion::Wasix64v1,
522            wasi_version_t::LATEST => WasiVersion::Latest,
523        })
524    }
525}
526
527#[unsafe(no_mangle)]
528pub unsafe extern "C" fn wasi_get_wasi_version(module: &wasm_module_t) -> wasi_version_t {
529    get_wasi_version(&module.inner, false)
530        .map(Into::into)
531        .unwrap_or(wasi_version_t::INVALID_VERSION)
532}
533
534/// Non-standard function to get the imports needed for the WASI
535/// implementation ordered as expected by the `wasm_module_t`.
536#[unsafe(no_mangle)]
537pub unsafe extern "C" fn wasi_get_imports(
538    _store: Option<&wasm_store_t>,
539    wasi_env: Option<&mut wasi_env_t>,
540    module: Option<&wasm_module_t>,
541    imports: &mut wasm_extern_vec_t,
542) -> bool {
543    unsafe { wasi_get_imports_inner(wasi_env, module, imports) }.is_some()
544}
545
546unsafe fn wasi_get_imports_inner(
547    wasi_env: Option<&mut wasi_env_t>,
548    module: Option<&wasm_module_t>,
549    imports: &mut wasm_extern_vec_t,
550) -> Option<()> {
551    let wasi_env = wasi_env?;
552    let store = &mut wasi_env.store;
553    let module = module?;
554
555    let mut import_object = {
556        let mut store_mut = unsafe { store.store_mut() };
557        c_try!(wasi_env.inner.import_object(&mut store_mut, &module.inner))
558    };
559
560    let shared_memory = module.inner.imports().memories().next().map(|a| *a.ty());
561
562    let spawn_type = match shared_memory {
563        Some(ty) => wasmer_wasix::runtime::SpawnType::CreateMemoryOfType(ty),
564        None => wasmer_wasix::runtime::SpawnType::CreateMemory,
565    };
566
567    let tasks = {
568        let store_ref = unsafe { store.store() };
569        wasi_env
570            .inner
571            .data(&store_ref)
572            .runtime
573            .task_manager()
574            .clone()
575    };
576    let memory = {
577        let mut store_mut = unsafe { store.store_mut() };
578        tasks.build_memory(&mut store_mut, &spawn_type).unwrap()
579    };
580
581    if let Some(memory) = memory {
582        import_object.define("env", "memory", memory);
583    }
584
585    imports_set_buffer(store, &module.inner, import_object, imports)?;
586
587    Some(())
588}
589
590pub(crate) fn imports_set_buffer(
591    store: &StoreRef,
592    module: &wasmer_api::Module,
593    import_object: wasmer_api::Imports,
594    imports: &mut wasm_extern_vec_t,
595) -> Option<()> {
596    imports.set_buffer(c_try!(
597        module
598            .imports()
599            .map(|import_type| {
600                let ext = import_object
601                    .get_export(import_type.module(), import_type.name())
602                    .ok_or_else(|| {
603                        format!(
604                            "Failed to resolve import \"{}\" \"{}\"",
605                            import_type.module(),
606                            import_type.name()
607                        )
608                    })?;
609
610                Ok(Some(Box::new(wasm_extern_t::new(store.clone(), ext))))
611            })
612            .collect::<Result<Vec<_>, String>>()
613    ));
614
615    Some(())
616}
617
618#[unsafe(no_mangle)]
619pub unsafe extern "C" fn wasi_env_initialize_instance(
620    wasi_env: &mut wasi_env_t,
621    store: &mut wasm_store_t,
622    instance: &mut wasm_instance_t,
623) -> bool {
624    let mut store_mut = unsafe { store.inner.store_mut() };
625    wasi_env
626        .inner
627        .initialize(&mut store_mut, instance.inner.clone())
628        .unwrap();
629    true
630}
631
632#[unsafe(no_mangle)]
633pub unsafe extern "C" fn wasi_get_start_function(
634    instance: &mut wasm_instance_t,
635) -> Option<Box<wasm_func_t>> {
636    let start = c_try!(instance.inner.exports.get_function("_start"));
637
638    Some(Box::new(wasm_func_t {
639        extern_: wasm_extern_t::new(instance.store.clone(), start.clone().into()),
640    }))
641}
642
643#[cfg(test)]
644mod tests {
645    #[cfg(not(target_os = "windows"))]
646    use inline_c::assert_c;
647    #[cfg(target_os = "windows")]
648    use wasmer_inline_c::assert_c;
649
650    #[allow(
651        unexpected_cfgs,
652        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
653    )]
654    #[cfg_attr(coverage_nightly, coverage(off))]
655    #[test]
656    fn test_wasi_get_wasi_version_snapshot0() {
657        (assert_c! {
658            #include "tests/wasmer.h"
659
660            int main() {
661                wasm_engine_t* engine = wasm_engine_new();
662                wasm_store_t* store = wasm_store_new(engine);
663                wasmer_funcenv_t* env = wasmer_funcenv_new(store, 0);
664
665                wasm_byte_vec_t wat;
666                wasmer_byte_vec_new_from_string(&wat, "(module (import \"wasi_unstable\" \"args_get\" (func (param i32 i32) (result i32))))");
667                wasm_byte_vec_t wasm;
668                wat2wasm(&wat, &wasm);
669
670                wasm_module_t* module = wasm_module_new(store, &wasm);
671                assert(module);
672
673                assert(wasi_get_wasi_version(module) == SNAPSHOT0);
674
675                wasm_module_delete(module);
676                wasm_byte_vec_delete(&wasm);
677                wasm_byte_vec_delete(&wat);
678                wasmer_funcenv_delete(env);
679                wasm_store_delete(store);
680                wasm_engine_delete(engine);
681
682                return 0;
683            }
684        })
685        .success();
686    }
687
688    #[allow(
689        unexpected_cfgs,
690        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
691    )]
692    #[cfg_attr(coverage_nightly, coverage(off))]
693    #[test]
694    fn test_wasi_get_wasi_version_snapshot1() {
695        (assert_c! {
696            #include "tests/wasmer.h"
697
698            int main() {
699                wasm_engine_t* engine = wasm_engine_new();
700                wasm_store_t* store = wasm_store_new(engine);
701                wasmer_funcenv_t* env = wasmer_funcenv_new(store, 0);
702
703                wasm_byte_vec_t wat;
704                wasmer_byte_vec_new_from_string(&wat, "(module (import \"wasi_snapshot_preview1\" \"args_get\" (func (param i32 i32) (result i32))))");
705                wasm_byte_vec_t wasm;
706                wat2wasm(&wat, &wasm);
707
708                wasm_module_t* module = wasm_module_new(store, &wasm);
709                assert(module);
710
711                assert(wasi_get_wasi_version(module) == SNAPSHOT1);
712
713                wasm_module_delete(module);
714                wasm_byte_vec_delete(&wasm);
715                wasm_byte_vec_delete(&wat);
716                wasmer_funcenv_delete(env);
717                wasm_store_delete(store);
718                wasm_engine_delete(engine);
719
720                return 0;
721            }
722        })
723        .success();
724    }
725
726    #[allow(
727        unexpected_cfgs,
728        reason = "tools like cargo-llvm-coverage pass --cfg coverage"
729    )]
730    #[cfg_attr(coverage_nightly, coverage(off))]
731    #[test]
732    fn test_wasi_get_wasi_version_invalid() {
733        (assert_c! {
734            #include "tests/wasmer.h"
735
736            int main() {
737                wasm_engine_t* engine = wasm_engine_new();
738                wasm_store_t* store = wasm_store_new(engine);
739                wasmer_funcenv_t* env = wasmer_funcenv_new(store, 0);
740
741                wasm_byte_vec_t wat;
742                wasmer_byte_vec_new_from_string(&wat, "(module (import \"wasi_snpsht_prvw1\" \"args_get\" (func (param i32 i32) (result i32))))");
743                wasm_byte_vec_t wasm;
744                wat2wasm(&wat, &wasm);
745
746                wasm_module_t* module = wasm_module_new(store, &wasm);
747                assert(module);
748
749                assert(wasi_get_wasi_version(module) == INVALID_VERSION);
750
751                wasm_module_delete(module);
752                wasm_byte_vec_delete(&wasm);
753                wasm_byte_vec_delete(&wat);
754                wasmer_funcenv_delete(env);
755                wasm_store_delete(store);
756                wasm_engine_delete(engine);
757
758                return 0;
759            }
760        })
761        .success();
762    }
763}
wasmer_c_api/wasm_c_api/wasi/mod.rs

wasmer_c_api/wasm_c_api/wasi/
mod.rs
