The branch main has been updated by kevans: URL: https://cgit.FreeBSD.org/src/commit/?id=c2caf3b3313fe73bfc9b4b984c21da8d571f8798
commit c2caf3b3313fe73bfc9b4b984c21da8d571f8798 Author: Kyle Evans <[email protected]> AuthorDate: 2023-03-11 06:03:02 +0000 Commit: Kyle Evans <[email protected]> CommitDate: 2024-09-30 03:52:20 +0000 flua: lposix: add more useful functions for general purpose scripts unistd: - _exit - close - fork - getpid - pipe - read - write libgen: - basename, dirname stdlib: - realpath These are sufficient for a number of real world scenarios. In our first application of them, we use the libgen+stdlib additions to grab the script dir based on argv[0]. The unistd assortment is then used to outsource a bunch of work to forks and report back to the main process. Reviewed by: emaste, imp Differential Revision: https://reviews.freebsd.org/D39083 --- libexec/flua/linit_flua.c | 3 + libexec/flua/modules/lposix.c | 415 ++++++++++++++++++++++++++++++++++++++---- libexec/flua/modules/lposix.h | 3 + 3 files changed, 388 insertions(+), 33 deletions(-) diff --git a/libexec/flua/linit_flua.c b/libexec/flua/linit_flua.c index 4635970d1fd7..5cae7531b7da 100644 --- a/libexec/flua/linit_flua.c +++ b/libexec/flua/linit_flua.c @@ -57,8 +57,11 @@ static const luaL_Reg loadedlibs[] = { #endif /* FreeBSD Extensions */ {"lfs", luaopen_lfs}, + {"posix.libgen", luaopen_posix_libgen}, + {"posix.stdlib", luaopen_posix_stdlib}, {"posix.sys.stat", luaopen_posix_sys_stat}, {"posix.sys.utsname", luaopen_posix_sys_utsname}, + {"posix.sys.wait", luaopen_posix_sys_wait}, {"posix.unistd", luaopen_posix_unistd}, {"fbsd", luaopen_fbsd}, {NULL, NULL} diff --git a/libexec/flua/modules/lposix.c b/libexec/flua/modules/lposix.c index fa3fd5f8e589..9ca57d409d10 100644 --- a/libexec/flua/modules/lposix.c +++ b/libexec/flua/modules/lposix.c @@ -1,35 +1,18 @@ /*- - * Copyright (c) 2019 Kyle Evans <[email protected]> - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. + * Copyright (c) 2019, 2023 Kyle Evans <[email protected]> * + * SPDX-License-Identifier: BSD-2-Clause */ #include <sys/stat.h> #include <sys/utsname.h> +#include <sys/wait.h> #include <errno.h> #include <grp.h> +#include <libgen.h> #include <pwd.h> +#include <stdlib.h> #include <string.h> #include <unistd.h> @@ -40,6 +23,39 @@ /* * Minimal implementation of luaposix needed for internal FreeBSD bits. */ +static int +lua__exit(lua_State *L) +{ + int code, narg; + + narg = lua_gettop(L); + luaL_argcheck(L, narg == 1, 1, "_exit takes exactly one argument"); + + code = luaL_checkinteger(L, 1); + _exit(code); +} + +static int +lua_basename(lua_State *L) +{ + char *inpath, *outpath; + int narg; + + narg = lua_gettop(L); + luaL_argcheck(L, narg > 0, 1, "at least one argument required"); + inpath = strdup(luaL_checkstring(L, 1)); + if (inpath == NULL) { + lua_pushnil(L); + lua_pushstring(L, strerror(ENOMEM)); + lua_pushinteger(L, ENOMEM); + return (3); + } + + outpath = basename(inpath); + lua_pushstring(L, outpath); + free(inpath); + return (1); +} static int lua_chmod(lua_State *L) @@ -57,10 +73,10 @@ lua_chmod(lua_State *L) lua_pushnil(L); lua_pushstring(L, strerror(errno)); lua_pushinteger(L, errno); - return 3; + return (3); } lua_pushinteger(L, 0); - return 1; + return (1); } static int @@ -120,14 +136,32 @@ lua_chown(lua_State *L) } static int -lua_getpid(lua_State *L) +lua_pclose(lua_State *L) { - int n; + int error, fd, n; n = lua_gettop(L); - luaL_argcheck(L, n == 0, 1, "too many arguments"); - lua_pushinteger(L, getpid()); - return 1; + luaL_argcheck(L, n == 1, 1, + "close takes exactly one argument (fd)"); + + fd = luaL_checkinteger(L, 1); + if (fd < 0) { + error = EBADF; + goto err; + } + + if (close(fd) == 0) { + lua_pushinteger(L, 0); + return (1); + } + + error = errno; +err: + lua_pushnil(L); + lua_pushstring(L, strerror(error)); + lua_pushinteger(L, error); + return (3); + } static int @@ -163,7 +197,271 @@ lua_uname(lua_State *L) return (1); } -#define REG_SIMPLE(n) { #n, lua_ ## n } +static int +lua_dirname(lua_State *L) +{ + char *inpath, *outpath; + int narg; + + narg = lua_gettop(L); + luaL_argcheck(L, narg > 0, 1, + "dirname takes at least one argument (path)"); + inpath = strdup(luaL_checkstring(L, 1)); + if (inpath == NULL) { + lua_pushnil(L); + lua_pushstring(L, strerror(ENOMEM)); + lua_pushinteger(L, ENOMEM); + return (3); + } + + outpath = dirname(inpath); + lua_pushstring(L, outpath); + free(inpath); + return (1); +} + +static int +lua_fork(lua_State *L) +{ + pid_t pid; + int narg; + + narg = lua_gettop(L); + luaL_argcheck(L, narg == 0, 1, "too many arguments"); + + pid = fork(); + if (pid < 0) { + lua_pushnil(L); + lua_pushstring(L, strerror(errno)); + lua_pushinteger(L, errno); + return (3); + } + + lua_pushinteger(L, pid); + return (1); +} + +static int +lua_getpid(lua_State *L) +{ + int narg; + + narg = lua_gettop(L); + luaL_argcheck(L, narg == 0, 1, "too many arguments"); + lua_pushinteger(L, getpid()); + return (1); +} + +static int +lua_pipe(lua_State *L) +{ + int error, fd[2], narg; + + narg = lua_gettop(L); + luaL_argcheck(L, narg == 0, 1, "too many arguments"); + + error = pipe(fd); + if (error != 0) { + lua_pushnil(L); + lua_pushstring(L, strerror(errno)); + lua_pushinteger(L, errno); + return (1); + } + + lua_pushinteger(L, fd[0]); + lua_pushinteger(L, fd[1]); + return (2); +} + +static int +lua_read(lua_State *L) +{ + char *buf; + ssize_t ret; + size_t sz; + int error, fd, narg; + + narg = lua_gettop(L); + luaL_argcheck(L, narg == 2, 1, + "read takes exactly two arguments (fd, size)"); + + fd = luaL_checkinteger(L, 1); + sz = luaL_checkinteger(L, 2); + + if (fd < 0) { + error = EBADF; + goto err; + } + + buf = malloc(sz); + if (buf == NULL) + goto err; + + /* + * For 0-byte reads, we'll still push the empty string and let the + * caller deal with EOF to match lposix semantics. + */ + ret = read(fd, buf, sz); + if (ret >= 0) + lua_pushlstring(L, buf, ret); + else if (ret < 0) + error = errno; /* Save to avoid clobber by free() */ + + free(buf); + if (error != 0) + goto err; + + /* Just the string pushed. */ + return (1); +err: + lua_pushnil(L); + lua_pushstring(L, strerror(error)); + lua_pushinteger(L, error); + return (3); +} + +static int +lua_realpath(lua_State *L) +{ + const char *inpath; + char *outpath; + int narg; + + narg = lua_gettop(L); + luaL_argcheck(L, narg > 0, 1, "at least one argument required"); + inpath = luaL_checkstring(L, 1); + + outpath = realpath(inpath, NULL); + if (outpath == NULL) { + lua_pushnil(L); + lua_pushstring(L, strerror(errno)); + lua_pushinteger(L, errno); + return (3); + } + + lua_pushstring(L, outpath); + free(outpath); + return (1); +} + +static int +lua_wait(lua_State *L) +{ + pid_t pid; + int options, status; + int narg; + + narg = lua_gettop(L); + + pid = -1; + status = options = 0; + if (narg >= 1 && !lua_isnil(L, 1)) + pid = luaL_checkinteger(L, 1); + if (narg >= 2 && !lua_isnil(L, 2)) + options = luaL_checkinteger(L, 2); + + pid = waitpid(pid, &status, options); + if (pid < 0) { + lua_pushnil(L); + lua_pushstring(L, strerror(errno)); + lua_pushinteger(L, errno); + return (3); + } + + lua_pushinteger(L, pid); + if (pid == 0) { + lua_pushliteral(L, "running"); + return (2); + } + + if (WIFCONTINUED(status)) { + lua_pushliteral(L, "continued"); + return (2); + } else if(WIFSTOPPED(status)) { + lua_pushliteral(L, "stopped"); + lua_pushinteger(L, WSTOPSIG(status)); + return (3); + } else if (WIFEXITED(status)) { + lua_pushliteral(L, "exited"); + lua_pushinteger(L, WEXITSTATUS(status)); + return (3); + } else if (WIFSIGNALED(status)) { + lua_pushliteral(L, "killed"); + lua_pushinteger(L, WTERMSIG(status)); + return (3); + } + + return (1); +} + +static int +lua_write(lua_State *L) +{ + const char *buf; + size_t bufsz, sz; + ssize_t ret; + off_t offset; + int error, fd, narg; + + narg = lua_gettop(L); + luaL_argcheck(L, narg >= 2, 1, + "write takes at least two arguments (fd, buf, sz, off)"); + luaL_argcheck(L, narg <= 4, 5, + "write takes no more than four arguments (fd, buf, sz, off)"); + + fd = luaL_checkinteger(L, 1); + if (fd < 0) { + error = EBADF; + goto err; + } + + buf = luaL_checkstring(L, 2); + + bufsz = sz = lua_rawlen(L, 2); + if (narg >= 3 && !lua_isnil(L, 3)) + sz = luaL_checkinteger(L, 3); + + offset = 0; + if (narg >= 4 && !lua_isnil(L, 4)) + offset = luaL_checkinteger(L, 4); + + if ((size_t)offset > bufsz || offset + sz > bufsz) { + lua_pushnil(L); + lua_pushfstring(L, + "write: invalid access offset %zu, size %zu in a buffer size %zu", + offset, sz, bufsz); + lua_pushinteger(L, EINVAL); + return (3); + } + + ret = write(fd, buf + offset, sz); + if (ret < 0) { + error = errno; + goto err; + } + + lua_pushinteger(L, ret); + return (1); +err: + lua_pushnil(L); + lua_pushstring(L, strerror(error)); + lua_pushinteger(L, error); + return (3); +} + +#define REG_DEF(n, func) { #n, func } +#define REG_SIMPLE(n) REG_DEF(n, lua_ ## n) +static const struct luaL_Reg libgenlib[] = { + REG_SIMPLE(basename), + REG_SIMPLE(dirname), + { NULL, NULL }, +}; + +static const struct luaL_Reg stdliblib[] = { + REG_SIMPLE(realpath), + { NULL, NULL }, +}; + static const struct luaL_Reg sys_statlib[] = { REG_SIMPLE(chmod), { NULL, NULL }, @@ -174,18 +472,69 @@ static const struct luaL_Reg sys_utsnamelib[] = { { NULL, NULL }, }; +static const struct luaL_Reg sys_waitlib[] = { + REG_SIMPLE(wait), + {NULL, NULL}, +}; + static const struct luaL_Reg unistdlib[] = { - REG_SIMPLE(getpid), + REG_SIMPLE(_exit), REG_SIMPLE(chown), + REG_DEF(close, lua_pclose), + REG_SIMPLE(fork), + REG_SIMPLE(getpid), + REG_SIMPLE(pipe), + REG_SIMPLE(read), + REG_SIMPLE(write), { NULL, NULL }, }; + #undef REG_SIMPLE +#undef REG_DEF + +int +luaopen_posix_libgen(lua_State *L) +{ + luaL_newlib(L, libgenlib); + return (1); +} + +int +luaopen_posix_stdlib(lua_State *L) +{ + luaL_newlib(L, stdliblib); + return (1); +} int luaopen_posix_sys_stat(lua_State *L) { luaL_newlib(L, sys_statlib); - return 1; + return (1); +} + +int +luaopen_posix_sys_wait(lua_State *L) +{ + luaL_newlib(L, sys_waitlib); + +#define lua_pushflag(L, flag) do { \ + lua_pushinteger(L, flag); \ + lua_setfield(L, -2, #flag); \ +} while(0) + + /* Only these two exported by lposix */ + lua_pushflag(L, WNOHANG); + lua_pushflag(L, WUNTRACED); + + lua_pushflag(L, WCONTINUED); + lua_pushflag(L, WSTOPPED); + lua_pushflag(L, WTRAPPED); + lua_pushflag(L, WEXITED); + lua_pushflag(L, WNOWAIT); +#undef lua_pushflag + + return (1); } int @@ -199,5 +548,5 @@ int luaopen_posix_unistd(lua_State *L) { luaL_newlib(L, unistdlib); - return 1; + return (1); } diff --git a/libexec/flua/modules/lposix.h b/libexec/flua/modules/lposix.h index e37caaae9d04..9d2c97b0d2dc 100644 --- a/libexec/flua/modules/lposix.h +++ b/libexec/flua/modules/lposix.h @@ -7,6 +7,9 @@ #include <lua.h> +int luaopen_posix_libgen(lua_State *L); +int luaopen_posix_stdlib(lua_State *L); int luaopen_posix_sys_stat(lua_State *L); int luaopen_posix_sys_utsname(lua_State *L); +int luaopen_posix_sys_wait(lua_State *L); int luaopen_posix_unistd(lua_State *L);
