~sircmpwn/hare-dev

hare: wordexp: new module v4 SUPERSEDED

Drew DeVault: 1
 wordexp: new module

 4 files changed, 155 insertions(+), 0 deletions(-)
#1097982 alpine.yml failed
#1097983 freebsd.yml success
Export patchset (mbox)
How do I use this?

Copy & paste the following snippet into your terminal to import this patchset into git:

curl -s https://lists.sr.ht/~sircmpwn/hare-dev/patches/46859/mbox | git am -3
Learn more about email & git

[PATCH hare v4] wordexp: new module Export this patch

Implements: https://todo.sr.ht/~sircmpwn/hare/274
Signed-off-by: Drew DeVault <sir@cmpwn.com>
---
From v3:
- All error cases originating from the shell have been merged into a
  general sh_error type. The shell's exit status is also tested and, if
  nonzero, sh_error is returned.
- Typo fixes and style edits

+1 to seb's suggestion that rc should have a word expansion mode for
Gaia.

 wordexp/+test.ha   | 49 ++++++++++++++++++++++++++++++
 wordexp/README     |  9 ++++++
 wordexp/error.ha   | 23 ++++++++++++++
 wordexp/wordexp.ha | 74 ++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 155 insertions(+)
 create mode 100644 wordexp/+test.ha
 create mode 100644 wordexp/README
 create mode 100644 wordexp/error.ha
 create mode 100644 wordexp/wordexp.ha

diff --git a/wordexp/+test.ha b/wordexp/+test.ha
new file mode 100644
index 00000000..cd14a24f
--- /dev/null
+++ b/wordexp/+test.ha
@@ -0,0 +1,49 @@
use os;
use strings;

fn streq(a: []str, b: []str) bool = {
	if (len(a) != len(b)) {
		return false;
	};
	for (let i = 0z; i < len(a); i += 1) {
		if (a[i] != b[i]) {
			return false;
		};
	};
	return true;
};

@test fn wordexp() void = {
	os::setenv("TESTVAR", "test value")!;
	os::unsetenv("UNSET")!;
	static const cases: [_](str, []str) = [
		(``, []),
		(`hello world`, ["hello", "world"]),
		(`hello $TESTVAR`, ["hello", "test", "value"]),
		(`hello "$TESTVAR"`, ["hello", "test value"]),
		(`hello $(echo world)`, ["hello", "world"]),
		(`hello $((2+2))`, ["hello", "4"]),
		(`hello $UNSET`, ["hello"]),
	];

	for (let i = 0z; i < len(cases); i += 1) {
		const (in, out) = cases[i];
		const words = wordexp(in, flag::NONE)!;
		defer strings::freeall(words);
		assert(streq(words, out));
	};
};

@test fn wordexp_error() void = {
	os::unsetenv("UNSET")!;
	static const cases: [_](str, flag) = [
		(`hello $UNSET`, flag::UNDEF),
		(`hello $(`, 0),
	];

	for (let i = 0z; i < len(cases); i += 1) {
		const (in, flag) = cases[i];
		const result = wordexp(in, flag);
		assert(result is sh_error);
	};
};
diff --git a/wordexp/README b/wordexp/README
new file mode 100644
index 00000000..a56cd8ff
--- /dev/null
+++ b/wordexp/README
@@ -0,0 +1,9 @@
The wordexp module implements word expansion using shell semantics, similar to
POSIX wordexp(3). Word expansion is performed with the platform-specific system
shell, which is generally POSIX sh(1) compatible on Unix-like systems.

When used with a POSIX shell, the IFS variable is unconditionally unset in the
environment, causing the shell to assume the default value of " \t\n".

Note that, by design, this module runs arbitrary shell commands from
user-supplied inputs. It must only be used in a trusted environment.
diff --git a/wordexp/error.ha b/wordexp/error.ha
new file mode 100644
index 00000000..2be5468e
--- /dev/null
+++ b/wordexp/error.ha
@@ -0,0 +1,23 @@
use encoding::utf8;
use io;
use os::exec;

// Tagged union of possible wordexp error conditions.
export type error = !(io::error | exec::error | utf8::invalid | sh_error);

// An error occured during shell expansion.
export type sh_error = !void;

// Converts an [[error]] to a human-friendly string.
export fn strerror(err: error) const str = {
	match (err) {
	case let err: io::error =>
		return io::strerror(err);
	case let err: exec::error =>
		return exec::strerror(err);
	case utf8::invalid =>
		return "Word expansion returned invalid UTF-8 data";
	case sh_error =>
		return "An error occured during shell expansion";
	};
};
diff --git a/wordexp/wordexp.ha b/wordexp/wordexp.ha
new file mode 100644
index 00000000..ac8624b9
--- /dev/null
+++ b/wordexp/wordexp.ha
@@ -0,0 +1,74 @@
// Based on the musl libc implementation
// Copyright © 2005-2020 Rich Felker, et al
// MIT license
use bufio;
use io;
use os;
use os::exec;
use strings;
use types;

// Flags applicable to a [[wordexp]] operation.
export type flag = enum uint {
	NONE = 0,
	// DOOFFS = (1 << 0),  // not implemented
	// APPEND = (1 << 1),  // not implemented
	// REUSE  = (1 << 3),  // not implemented
	// NOCMD   = (1 << 2), // not implemented
	SHOWERR = (1 << 4),
	UNDEF   = (1 << 5),
};

// Performs shell expansion and word splitting on the provided string, returning
// a list of expanded words, similar to POSIX wordexp(3). Note that this
// function, by design, will execute arbitrary commands from the input string.
//
// Pass the return value to [[strings::freeall]] to free resources associated
// with the return value.
export fn wordexp(s: str, flags: flag) ([]str | error) = {
	const (rd, wr) = exec::pipe();
	const child = match (exec::fork()?) {
	case let proc: exec::process =>
		io::close(wr)!;
		yield proc;
	case void =>
		// "x" is added to detect syntax errors, it is discarded later
		const cmd = exec::cmd("/bin/sh",
			if (flags & flag::UNDEF != 0) "-uc" else "-c",
			`eval "printf %s\\\\0 x $1"`, "sh", s)!;
		exec::unsetenv(&cmd, "IFS")!;
		exec::addfile(&cmd, os::stdout_file, wr);
		if (flags & flag::SHOWERR == 0) {
			exec::addfile(&cmd, os::stderr_file, exec::nullfd);
		};
		io::close(rd)!;
		exec::exec(&cmd);
	};

	const scan = bufio::newscanner(rd, types::SIZE_MAX);
	defer bufio::finish(&scan);

	match (bufio::scan_string(&scan, "\0")?) {
	case io::EOF =>
		return sh_error;
	case => void; // Discard the first "x" argument
	};

	let words: []str = [];
	for (true) {
		match (bufio::scan_string(&scan, "\0")?) {
		case io::EOF => break;
		case let word: const str =>
			append(words, strings::dup(word));
		};
	};

	io::close(rd)!;
	const st = exec::wait(&child)!;
	match (exec::check(&st)) {
	case !exec::exit_status =>
		return sh_error;
	case void =>
		return words;
	};
};
-- 
2.42.1
hare/patches: FAILED in 1m38s

[wordexp: new module][0] v4 from [Drew DeVault][1]

[0]: https://lists.sr.ht/~sircmpwn/hare-dev/patches/46859
[1]: mailto:sir@cmpwn.com

✓ #1097983 SUCCESS hare/patches/freebsd.yml https://builds.sr.ht/~sircmpwn/job/1097983
✗ #1097982 FAILED  hare/patches/alpine.yml  https://builds.sr.ht/~sircmpwn/job/1097982