mirror of
https://github.com/mkxp-z/mkxp-z.git
synced 2025-08-23 15:23:44 +02:00
5a5fcd26c5
The copy constructors are causing problems when the `fiber.stack` vector gets reallocated when its capacity is full, since when vectors are reallocated, the elements are moved (or copied if there's no usable move constructor) to the reallocated memory and then the original elements are destroyed. This premature calling of destructors leads to double-free and use-after-free errors. I fixed it by deleting the copy constructors and explicitly defining move constructors.
125 lines
4.1 KiB
C++
125 lines
4.1 KiB
C++
/*
|
|
** sandbox.h
|
|
**
|
|
** This file is part of mkxp.
|
|
**
|
|
** Copyright (C) 2013 - 2021 Amaryllis Kulla <ancurio@mapleshrine.eu>
|
|
**
|
|
** mkxp is free software: you can redistribute it and/or modify
|
|
** it under the terms of the GNU General Public License as published by
|
|
** the Free Software Foundation, either version 2 of the License, or
|
|
** (at your option) any later version.
|
|
**
|
|
** mkxp is distributed in the hope that it will be useful,
|
|
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
** GNU General Public License for more details.
|
|
**
|
|
** You should have received a copy of the GNU General Public License
|
|
** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef MKXPZ_SANDBOX_H
|
|
#define MKXPZ_SANDBOX_H
|
|
|
|
#include <memory>
|
|
#include <boost/optional.hpp>
|
|
#include <mkxp-sandbox-bindgen.h>
|
|
#include "types.h"
|
|
|
|
#define SANDBOX_COROUTINE(name, definition) struct name : boost::asio::coroutine { inline name(struct mkxp_sandbox::binding_base &bind) {} definition };
|
|
|
|
#define SANDBOX_AWAIT(coroutine, ...) \
|
|
do { \
|
|
{ \
|
|
struct mkxp_sandbox::bindings::stack_frame_guard<struct coroutine> frame = mkxp_sandbox::sb()->bind<struct coroutine>(); \
|
|
frame()(__VA_ARGS__); \
|
|
if (frame().is_complete()) break; \
|
|
} \
|
|
BOOST_ASIO_CORO_YIELD; \
|
|
} while (1)
|
|
|
|
#define SANDBOX_AWAIT_AND_SET(variable, coroutine, ...) \
|
|
do { \
|
|
{ \
|
|
struct mkxp_sandbox::bindings::stack_frame_guard<struct coroutine> frame = mkxp_sandbox::sb()->bind<struct coroutine>(); \
|
|
auto ret = frame()(__VA_ARGS__); \
|
|
if (frame().is_complete()) { \
|
|
variable = ret; \
|
|
break; \
|
|
} \
|
|
} \
|
|
BOOST_ASIO_CORO_YIELD; \
|
|
} while (1)
|
|
|
|
#define SANDBOX_YIELD \
|
|
do { \
|
|
sb()._begin_yield(); \
|
|
BOOST_ASIO_CORO_YIELD; \
|
|
sb()._end_yield(); \
|
|
} while (0)
|
|
|
|
#define SANDBOX_VALUE_TO_BOOL(value) ((value) != SANDBOX_FALSE && (value) != SANDBOX_NIL)
|
|
|
|
#define SANDBOX_BOOL_TO_VALUE(boolean) ((boolean) ? SANDBOX_TRUE : SANDBOX_FALSE)
|
|
|
|
namespace mkxp_sandbox {
|
|
struct sandbox;
|
|
}
|
|
|
|
namespace mkxp_retro {
|
|
extern boost::optional<struct mkxp_sandbox::sandbox> sandbox;
|
|
}
|
|
|
|
namespace mkxp_sandbox {
|
|
struct sandbox {
|
|
private:
|
|
std::shared_ptr<struct w2c_ruby> ruby;
|
|
std::unique_ptr<struct w2c_wasi__snapshot__preview1> wasi;
|
|
boost::optional<struct mkxp_sandbox::bindings> bindings;
|
|
bool yielding;
|
|
usize sandbox_malloc(usize size);
|
|
void sandbox_free(usize ptr);
|
|
|
|
public:
|
|
inline struct mkxp_sandbox::bindings &operator*() noexcept { return *bindings; }
|
|
inline struct mkxp_sandbox::bindings *operator->() noexcept { return &*bindings; }
|
|
sandbox();
|
|
~sandbox();
|
|
|
|
// Internal utility method of the `SANDBOX_YIELD` macro.
|
|
inline void _begin_yield() {
|
|
yielding = true;
|
|
w2c_ruby_asyncify_start_unwind(ruby.get(), ruby->w2c_mkxp_sandbox_async_buf);
|
|
}
|
|
|
|
// Internal utility method of the `SANDBOX_YIELD` macro.
|
|
inline void _end_yield() {
|
|
w2c_ruby_asyncify_stop_rewind(ruby.get());
|
|
}
|
|
|
|
// Executes the given coroutine as the top-level coroutine. Don't call this from inside of another coroutine; use `sb()->bind<T>()` instead.
|
|
// Returns whether or not the coroutine completed execution.
|
|
template <typename T> inline bool run() {
|
|
if (yielding) {
|
|
w2c_ruby_asyncify_start_rewind(ruby.get(), ruby->w2c_mkxp_sandbox_async_buf);
|
|
yielding = false;
|
|
}
|
|
for (;;) {
|
|
{
|
|
struct mkxp_sandbox::bindings::stack_frame_guard<T> frame = bindings->bind<T>();
|
|
frame()();
|
|
if (yielding || frame().is_complete()) break;
|
|
}
|
|
w2c_ruby_mkxp_sandbox_yield(ruby.get());
|
|
}
|
|
return !yielding;
|
|
}
|
|
};
|
|
|
|
inline struct sandbox &sb() noexcept {
|
|
return *mkxp_retro::sandbox;
|
|
}
|
|
}
|
|
|
|
#endif // MKXPZ_SANDBOX_H
|