2020-06-17 16:35:06 +03:00
|
|
|
/*
|
2021-04-28 23:46:44 +03:00
|
|
|
* Copyright (c) 2020, the SerenityOS developers.
|
2020-06-17 16:35:06 +03:00
|
|
|
*
|
2021-04-22 11:24:48 +03:00
|
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
2020-06-17 16:35:06 +03:00
|
|
|
*/
|
|
|
|
|
2021-01-03 12:09:27 +03:00
|
|
|
#include "AST.h"
|
2020-06-17 16:35:06 +03:00
|
|
|
#include "Shell.h"
|
2021-04-11 06:25:49 +03:00
|
|
|
#include "Shell/Formatter.h"
|
2020-06-17 16:35:06 +03:00
|
|
|
#include <AK/LexicalPath.h>
|
2021-01-03 12:09:27 +03:00
|
|
|
#include <AK/ScopeGuard.h>
|
2020-06-17 16:35:06 +03:00
|
|
|
#include <LibCore/ArgsParser.h>
|
2020-12-07 19:07:04 +03:00
|
|
|
#include <LibCore/EventLoop.h>
|
2020-06-17 16:35:06 +03:00
|
|
|
#include <LibCore/File.h>
|
2021-03-12 19:29:37 +03:00
|
|
|
#include <errno.h>
|
2020-06-25 15:45:23 +03:00
|
|
|
#include <inttypes.h>
|
2021-04-23 16:56:27 +03:00
|
|
|
#include <limits.h>
|
2020-06-17 16:35:06 +03:00
|
|
|
#include <signal.h>
|
|
|
|
#include <sys/wait.h>
|
2020-07-14 21:52:52 +03:00
|
|
|
#include <unistd.h>
|
2020-06-17 16:35:06 +03:00
|
|
|
|
2020-07-14 21:52:52 +03:00
|
|
|
extern char** environ;
|
2020-06-17 16:35:06 +03:00
|
|
|
|
2020-10-01 17:43:01 +03:00
|
|
|
namespace Shell {
|
|
|
|
|
2021-01-18 04:04:16 +03:00
|
|
|
int Shell::builtin_dump(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
if (argc != 2)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
Parser { argv[1] }.parse()->dump(0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-06-17 17:21:44 +03:00
|
|
|
int Shell::builtin_alias(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
Vector<const char*> arguments;
|
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
|
|
|
parser.add_positional_argument(arguments, "List of name[=values]'s", "name[=value]", Core::ArgsParser::Required::No);
|
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (arguments.is_empty()) {
|
|
|
|
for (auto& alias : m_aliases)
|
|
|
|
printf("%s=%s\n", escape_token(alias.key).characters(), escape_token(alias.value).characters());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool fail = false;
|
|
|
|
for (auto& argument : arguments) {
|
|
|
|
auto parts = String { argument }.split_limit('=', 2, true);
|
|
|
|
if (parts.size() == 1) {
|
|
|
|
auto alias = m_aliases.get(parts[0]);
|
|
|
|
if (alias.has_value()) {
|
|
|
|
printf("%s=%s\n", escape_token(parts[0]).characters(), escape_token(alias.value()).characters());
|
|
|
|
} else {
|
|
|
|
fail = true;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
m_aliases.set(parts[0], parts[1]);
|
2020-08-03 12:06:42 +03:00
|
|
|
add_entry_to_cache(parts[0]);
|
2020-06-17 17:21:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return fail ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
2020-06-17 16:35:06 +03:00
|
|
|
int Shell::builtin_bg(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
int job_id = -1;
|
2021-04-23 16:56:27 +03:00
|
|
|
bool is_pid = false;
|
2020-06-17 16:35:06 +03:00
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
2021-04-23 16:56:27 +03:00
|
|
|
parser.add_positional_argument(Core::ArgsParser::Arg {
|
|
|
|
.help_string = "Job ID or Jobspec to run in background",
|
|
|
|
.name = "job-id",
|
|
|
|
.min_values = 0,
|
|
|
|
.max_values = 1,
|
|
|
|
.accept_value = [&](const String& value) -> bool {
|
|
|
|
// Check if it's a pid (i.e. literal integer)
|
|
|
|
if (auto number = value.to_uint(); number.has_value()) {
|
|
|
|
job_id = number.value();
|
|
|
|
is_pid = true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if it's a jobspec
|
|
|
|
if (auto id = resolve_job_spec(value); id.has_value()) {
|
|
|
|
job_id = id.value();
|
|
|
|
is_pid = false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
} });
|
2020-06-17 16:35:06 +03:00
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (job_id == -1 && !jobs.is_empty())
|
|
|
|
job_id = find_last_job_id();
|
|
|
|
|
2021-04-23 16:56:27 +03:00
|
|
|
auto* job = const_cast<Job*>(find_job(job_id, is_pid));
|
2020-06-17 16:35:06 +03:00
|
|
|
|
|
|
|
if (!job) {
|
|
|
|
if (job_id == -1) {
|
2021-04-23 16:56:27 +03:00
|
|
|
warnln("bg: No current job");
|
2020-06-17 16:35:06 +03:00
|
|
|
} else {
|
2021-04-23 16:56:27 +03:00
|
|
|
warnln("bg: Job with id/pid {} not found", job_id);
|
2020-06-17 16:35:06 +03:00
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
job->set_running_in_background(true);
|
2020-12-10 17:02:18 +03:00
|
|
|
job->set_should_announce_exit(true);
|
2021-03-30 00:49:02 +03:00
|
|
|
job->set_shell_did_continue(true);
|
2020-06-17 16:35:06 +03:00
|
|
|
|
2020-10-26 02:05:22 +03:00
|
|
|
dbgln("Resuming {} ({})", job->pid(), job->cmd());
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("Resuming job {} - {}", job->job_id(), job->cmd());
|
2020-06-17 16:35:06 +03:00
|
|
|
|
2020-10-26 02:05:22 +03:00
|
|
|
// Try using the PGID, but if that fails, just use the PID.
|
2020-06-17 16:35:06 +03:00
|
|
|
if (killpg(job->pgid(), SIGCONT) < 0) {
|
2020-10-26 02:05:22 +03:00
|
|
|
if (kill(job->pid(), SIGCONT) < 0) {
|
|
|
|
perror("kill");
|
|
|
|
return 1;
|
|
|
|
}
|
2020-06-17 16:35:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-04-11 06:25:49 +03:00
|
|
|
int Shell::builtin_type(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
Vector<const char*> commands;
|
|
|
|
bool dont_show_function_source = false;
|
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
|
|
|
parser.set_general_help("Display information about commands.");
|
|
|
|
parser.add_positional_argument(commands, "Command(s) to list info about", "command");
|
|
|
|
parser.add_option(dont_show_function_source, "Do not show functions source.", "no-fn-source", 'f');
|
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
bool something_not_found = false;
|
|
|
|
|
|
|
|
for (auto& command : commands) {
|
|
|
|
// check if it is an alias
|
|
|
|
if (auto alias = m_aliases.get(command); alias.has_value()) {
|
|
|
|
printf("%s is aliased to `%s`\n", escape_token(command).characters(), escape_token(alias.value()).characters());
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// check if it is a function
|
|
|
|
if (auto function = m_functions.get(command); function.has_value()) {
|
|
|
|
auto fn = function.value();
|
|
|
|
printf("%s is a function\n", command);
|
|
|
|
if (!dont_show_function_source) {
|
|
|
|
StringBuilder builder;
|
|
|
|
builder.append(fn.name);
|
|
|
|
builder.append("(");
|
|
|
|
for (size_t i = 0; i < fn.arguments.size(); i++) {
|
|
|
|
builder.append(fn.arguments[i]);
|
|
|
|
if (!(i == fn.arguments.size() - 1))
|
|
|
|
builder.append(" ");
|
|
|
|
}
|
|
|
|
builder.append(") {\n");
|
|
|
|
if (fn.body) {
|
|
|
|
auto formatter = Formatter(*fn.body);
|
|
|
|
builder.append(formatter.format());
|
|
|
|
printf("%s\n}\n", builder.build().characters());
|
|
|
|
} else {
|
|
|
|
printf("%s\n}\n", builder.build().characters());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// check if its a builtin
|
|
|
|
if (has_builtin(command)) {
|
|
|
|
printf("%s is a shell builtin\n", command);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// check if its an executable in PATH
|
|
|
|
auto fullpath = Core::find_executable_in_path(command);
|
|
|
|
if (!fullpath.is_null()) {
|
|
|
|
printf("%s is %s\n", command, escape_token(fullpath).characters());
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
something_not_found = true;
|
|
|
|
printf("type: %s not found\n", command);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (something_not_found)
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-06-17 16:35:06 +03:00
|
|
|
int Shell::builtin_cd(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
const char* arg_path = nullptr;
|
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
|
|
|
parser.add_positional_argument(arg_path, "Path to change to", "path", Core::ArgsParser::Required::No);
|
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
String new_path;
|
|
|
|
|
|
|
|
if (!arg_path) {
|
|
|
|
new_path = home;
|
|
|
|
} else {
|
|
|
|
if (strcmp(arg_path, "-") == 0) {
|
|
|
|
char* oldpwd = getenv("OLDPWD");
|
|
|
|
if (oldpwd == nullptr)
|
|
|
|
return 1;
|
|
|
|
new_path = oldpwd;
|
|
|
|
} else {
|
2021-04-23 11:42:16 +03:00
|
|
|
new_path = arg_path;
|
2020-06-17 16:35:06 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
auto real_path = Core::File::real_path_for(new_path);
|
|
|
|
if (real_path.is_empty()) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("Invalid path '{}'", new_path);
|
2020-06-17 16:35:06 +03:00
|
|
|
return 1;
|
|
|
|
}
|
2020-10-26 02:07:43 +03:00
|
|
|
|
|
|
|
if (cd_history.is_empty() || cd_history.last() != real_path)
|
|
|
|
cd_history.enqueue(real_path);
|
|
|
|
|
2020-06-17 16:35:06 +03:00
|
|
|
const char* path = real_path.characters();
|
|
|
|
|
|
|
|
int rc = chdir(path);
|
|
|
|
if (rc < 0) {
|
|
|
|
if (errno == ENOTDIR) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("Not a directory: {}", path);
|
2020-06-17 16:35:06 +03:00
|
|
|
} else {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("chdir({}) failed: {}", path, strerror(errno));
|
2020-06-17 16:35:06 +03:00
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
setenv("OLDPWD", cwd.characters(), 1);
|
|
|
|
cwd = real_path;
|
|
|
|
setenv("PWD", cwd.characters(), 1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Shell::builtin_cdh(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
int index = -1;
|
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
|
|
|
parser.add_positional_argument(index, "Index of the cd history entry (leave out for a list)", "index", Core::ArgsParser::Required::No);
|
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (index == -1) {
|
|
|
|
if (cd_history.is_empty()) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("cdh: no history available");
|
2020-06-17 16:35:06 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (ssize_t i = cd_history.size() - 1; i >= 0; --i)
|
|
|
|
printf("%lu: %s\n", cd_history.size() - i, cd_history.at(i).characters());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (index < 1 || (size_t)index > cd_history.size()) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("cdh: history index out of bounds: {} not in (0, {})", index, cd_history.size());
|
2020-06-17 16:35:06 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char* path = cd_history.at(cd_history.size() - index).characters();
|
|
|
|
const char* cd_args[] = { "cd", path, nullptr };
|
|
|
|
return Shell::builtin_cd(2, cd_args);
|
|
|
|
}
|
|
|
|
|
|
|
|
int Shell::builtin_dirs(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
// The first directory in the stack is ALWAYS the current directory
|
|
|
|
directory_stack.at(0) = cwd.characters();
|
|
|
|
|
|
|
|
bool clear = false;
|
|
|
|
bool print = false;
|
|
|
|
bool number_when_printing = false;
|
|
|
|
char separator = ' ';
|
|
|
|
|
|
|
|
Vector<const char*> paths;
|
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
|
|
|
parser.add_option(clear, "Clear the directory stack", "clear", 'c');
|
|
|
|
parser.add_option(print, "Print directory entries one per line", "print", 'p');
|
|
|
|
parser.add_option(number_when_printing, "Number the directories in the stack when printing", "number", 'v');
|
|
|
|
parser.add_positional_argument(paths, "Extra paths to put on the stack", "path", Core::ArgsParser::Required::No);
|
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
// -v implies -p
|
|
|
|
print = print || number_when_printing;
|
|
|
|
|
|
|
|
if (print) {
|
|
|
|
if (!paths.is_empty()) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("dirs: 'print' and 'number' are not allowed when any path is specified");
|
2020-06-17 16:35:06 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
separator = '\n';
|
|
|
|
}
|
|
|
|
|
|
|
|
if (clear) {
|
|
|
|
for (size_t i = 1; i < directory_stack.size(); i++)
|
|
|
|
directory_stack.remove(i);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto& path : paths)
|
|
|
|
directory_stack.append(path);
|
|
|
|
|
|
|
|
if (print || (!clear && paths.is_empty())) {
|
|
|
|
int index = 0;
|
|
|
|
for (auto& directory : directory_stack) {
|
|
|
|
if (number_when_printing)
|
|
|
|
printf("%d ", index++);
|
|
|
|
print_path(directory);
|
|
|
|
fputc(separator, stdout);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-12-29 22:42:34 +03:00
|
|
|
int Shell::builtin_exec(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
if (argc < 2) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("Shell: No command given to exec");
|
2020-12-29 22:42:34 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
Vector<const char*> argv_vector;
|
|
|
|
argv_vector.append(argv + 1, argc - 1);
|
|
|
|
argv_vector.append(nullptr);
|
|
|
|
|
|
|
|
execute_process(move(argv_vector));
|
|
|
|
}
|
|
|
|
|
2020-06-17 16:35:06 +03:00
|
|
|
int Shell::builtin_exit(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
int exit_code = 0;
|
|
|
|
Core::ArgsParser parser;
|
|
|
|
parser.add_positional_argument(exit_code, "Exit code", "code", Core::ArgsParser::Required::No);
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv)))
|
|
|
|
return 1;
|
|
|
|
|
2020-10-27 16:43:43 +03:00
|
|
|
if (m_is_interactive) {
|
|
|
|
if (!jobs.is_empty()) {
|
|
|
|
if (!m_should_ignore_jobs_on_next_exit) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("Shell: You have {} active job{}, run 'exit' again to really exit.", jobs.size(), jobs.size() > 1 ? "s" : "");
|
2020-10-27 16:43:43 +03:00
|
|
|
m_should_ignore_jobs_on_next_exit = true;
|
|
|
|
return 1;
|
|
|
|
}
|
2020-06-17 16:35:06 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
stop_all_jobs();
|
2021-03-07 09:12:24 +03:00
|
|
|
if (m_is_interactive) {
|
|
|
|
m_editor->save_history(get_history_path());
|
2020-08-05 08:30:01 +03:00
|
|
|
printf("Good-bye!\n");
|
2021-03-07 09:12:24 +03:00
|
|
|
}
|
2020-06-17 16:35:06 +03:00
|
|
|
exit(exit_code);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Shell::builtin_export(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
Vector<const char*> vars;
|
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
|
|
|
parser.add_positional_argument(vars, "List of variable[=value]'s", "values", Core::ArgsParser::Required::No);
|
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (vars.is_empty()) {
|
|
|
|
for (size_t i = 0; environ[i]; ++i)
|
|
|
|
puts(environ[i]);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto& value : vars) {
|
|
|
|
auto parts = String { value }.split_limit('=', 2);
|
|
|
|
|
|
|
|
if (parts.size() == 1) {
|
|
|
|
auto value = lookup_local_variable(parts[0]);
|
|
|
|
if (value) {
|
|
|
|
auto values = value->resolve_as_list(*this);
|
|
|
|
StringBuilder builder;
|
|
|
|
builder.join(" ", values);
|
|
|
|
parts.append(builder.to_string());
|
|
|
|
} else {
|
|
|
|
// Ignore the export.
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int setenv_return = setenv(parts[0].characters(), parts[1].characters(), 1);
|
|
|
|
|
|
|
|
if (setenv_return != 0) {
|
|
|
|
perror("setenv");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (parts[0] == "PATH")
|
|
|
|
cache_path();
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-12-01 14:24:00 +03:00
|
|
|
int Shell::builtin_glob(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
Vector<const char*> globs;
|
|
|
|
Core::ArgsParser parser;
|
|
|
|
parser.add_positional_argument(globs, "Globs to resolve", "glob");
|
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
for (auto& glob : globs) {
|
|
|
|
for (auto& expanded : expand_globs(glob, cwd))
|
|
|
|
outln("{}", expanded);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-06-17 16:35:06 +03:00
|
|
|
int Shell::builtin_fg(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
int job_id = -1;
|
2021-04-23 16:56:27 +03:00
|
|
|
bool is_pid = false;
|
2020-06-17 16:35:06 +03:00
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
2021-04-23 16:56:27 +03:00
|
|
|
parser.add_positional_argument(Core::ArgsParser::Arg {
|
|
|
|
.help_string = "Job ID or Jobspec to bring to foreground",
|
|
|
|
.name = "job-id",
|
|
|
|
.min_values = 0,
|
|
|
|
.max_values = 1,
|
|
|
|
.accept_value = [&](const String& value) -> bool {
|
|
|
|
// Check if it's a pid (i.e. literal integer)
|
|
|
|
if (auto number = value.to_uint(); number.has_value()) {
|
|
|
|
job_id = number.value();
|
|
|
|
is_pid = true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if it's a jobspec
|
|
|
|
if (auto id = resolve_job_spec(value); id.has_value()) {
|
|
|
|
job_id = id.value();
|
|
|
|
is_pid = false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
} });
|
2020-06-17 16:35:06 +03:00
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (job_id == -1 && !jobs.is_empty())
|
|
|
|
job_id = find_last_job_id();
|
|
|
|
|
2021-04-23 16:56:27 +03:00
|
|
|
RefPtr<Job> job = find_job(job_id, is_pid);
|
2020-06-17 16:35:06 +03:00
|
|
|
|
|
|
|
if (!job) {
|
|
|
|
if (job_id == -1) {
|
2021-04-23 16:56:27 +03:00
|
|
|
warnln("fg: No current job");
|
2020-06-17 16:35:06 +03:00
|
|
|
} else {
|
2021-04-23 16:56:27 +03:00
|
|
|
warnln("fg: Job with id/pid {} not found", job_id);
|
2020-06-17 16:35:06 +03:00
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
job->set_running_in_background(false);
|
2021-03-30 00:49:02 +03:00
|
|
|
job->set_shell_did_continue(true);
|
2020-06-17 16:35:06 +03:00
|
|
|
|
2020-10-26 02:05:22 +03:00
|
|
|
dbgln("Resuming {} ({})", job->pid(), job->cmd());
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("Resuming job {} - {}", job->job_id(), job->cmd());
|
2020-06-17 16:35:06 +03:00
|
|
|
|
2020-08-06 16:50:57 +03:00
|
|
|
tcsetpgrp(STDOUT_FILENO, job->pgid());
|
|
|
|
tcsetpgrp(STDIN_FILENO, job->pgid());
|
|
|
|
|
2020-10-26 02:05:22 +03:00
|
|
|
// Try using the PGID, but if that fails, just use the PID.
|
2020-06-17 16:35:06 +03:00
|
|
|
if (killpg(job->pgid(), SIGCONT) < 0) {
|
2020-10-26 02:05:22 +03:00
|
|
|
if (kill(job->pid(), SIGCONT) < 0) {
|
|
|
|
perror("kill");
|
|
|
|
return 1;
|
|
|
|
}
|
2020-06-17 16:35:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
block_on_job(job);
|
|
|
|
|
2020-08-12 04:59:21 +03:00
|
|
|
if (job->exited())
|
|
|
|
return job->exit_code();
|
|
|
|
else
|
|
|
|
return 0;
|
2020-06-17 16:35:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
int Shell::builtin_disown(int argc, const char** argv)
|
|
|
|
{
|
2021-04-23 16:56:27 +03:00
|
|
|
Vector<int> job_ids;
|
|
|
|
Vector<bool> id_is_pid;
|
2020-06-17 16:35:06 +03:00
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
2021-04-23 16:56:27 +03:00
|
|
|
parser.add_positional_argument(Core::ArgsParser::Arg {
|
|
|
|
.help_string = "Job IDs or Jobspecs to disown",
|
|
|
|
.name = "job-id",
|
|
|
|
.min_values = 0,
|
|
|
|
.max_values = INT_MAX,
|
|
|
|
.accept_value = [&](const String& value) -> bool {
|
|
|
|
// Check if it's a pid (i.e. literal integer)
|
|
|
|
if (auto number = value.to_uint(); number.has_value()) {
|
|
|
|
job_ids.append(number.value());
|
|
|
|
id_is_pid.append(true);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if it's a jobspec
|
|
|
|
if (auto id = resolve_job_spec(value); id.has_value()) {
|
|
|
|
job_ids.append(id.value());
|
|
|
|
id_is_pid.append(false);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
} });
|
2020-06-17 16:35:06 +03:00
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
2021-04-23 16:56:27 +03:00
|
|
|
if (job_ids.is_empty()) {
|
2020-07-12 17:21:47 +03:00
|
|
|
job_ids.append(find_last_job_id());
|
2021-04-23 16:56:27 +03:00
|
|
|
id_is_pid.append(false);
|
|
|
|
}
|
2020-06-17 16:35:06 +03:00
|
|
|
|
2020-07-12 17:21:47 +03:00
|
|
|
Vector<const Job*> jobs_to_disown;
|
2020-06-17 16:35:06 +03:00
|
|
|
|
2021-04-23 16:56:27 +03:00
|
|
|
for (size_t i = 0; i < job_ids.size(); ++i) {
|
|
|
|
auto id = job_ids[i];
|
|
|
|
auto is_pid = id_is_pid[i];
|
|
|
|
auto job = find_job(id, is_pid);
|
2020-07-12 17:21:47 +03:00
|
|
|
if (!job)
|
2021-04-23 16:56:27 +03:00
|
|
|
warnln("disown: Job with id/pid {} not found", id);
|
2020-07-12 17:21:47 +03:00
|
|
|
else
|
|
|
|
jobs_to_disown.append(job);
|
2020-06-17 16:35:06 +03:00
|
|
|
}
|
2020-07-12 17:21:47 +03:00
|
|
|
|
|
|
|
if (jobs_to_disown.is_empty()) {
|
2021-04-23 16:56:27 +03:00
|
|
|
if (job_ids.is_empty())
|
|
|
|
warnln("disown: No current job");
|
2020-06-17 16:35:06 +03:00
|
|
|
// An error message has already been printed about the nonexistence of each listed job.
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2020-07-12 17:21:47 +03:00
|
|
|
for (auto job : jobs_to_disown) {
|
2020-06-17 16:35:06 +03:00
|
|
|
job->deactivate();
|
|
|
|
|
|
|
|
if (!job->is_running_in_background())
|
2021-04-23 16:56:27 +03:00
|
|
|
warnln("disown warning: Job {} is currently not running, 'kill -{} {}' to make it continue", job->job_id(), SIGCONT, job->pid());
|
2020-06-17 16:35:06 +03:00
|
|
|
|
2020-07-12 17:21:47 +03:00
|
|
|
jobs.remove(job->pid());
|
2020-06-17 16:35:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Shell::builtin_history(int, const char**)
|
|
|
|
{
|
2020-09-23 08:36:30 +03:00
|
|
|
for (size_t i = 0; i < m_editor->history().size(); ++i) {
|
2021-01-11 18:28:42 +03:00
|
|
|
printf("%6zu %s\n", i, m_editor->history()[i].entry.characters());
|
2020-06-17 16:35:06 +03:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Shell::builtin_jobs(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
bool list = false, show_pid = false;
|
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
|
|
|
parser.add_option(list, "List all information about jobs", "list", 'l');
|
|
|
|
parser.add_option(show_pid, "Display the PID of the jobs", "pid", 'p');
|
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
2020-08-06 16:09:25 +03:00
|
|
|
Job::PrintStatusMode mode = Job::PrintStatusMode::Basic;
|
2020-06-17 16:35:06 +03:00
|
|
|
|
|
|
|
if (show_pid)
|
2020-08-06 16:09:25 +03:00
|
|
|
mode = Job::PrintStatusMode::OnlyPID;
|
2020-06-17 16:35:06 +03:00
|
|
|
|
|
|
|
if (list)
|
2020-08-06 16:09:25 +03:00
|
|
|
mode = Job::PrintStatusMode::ListAll;
|
2020-06-17 16:35:06 +03:00
|
|
|
|
2020-08-06 16:09:25 +03:00
|
|
|
for (auto& it : jobs) {
|
|
|
|
if (!it.value->print_status(mode))
|
|
|
|
return 1;
|
2020-06-17 16:35:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Shell::builtin_popd(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
if (directory_stack.size() <= 1) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("Shell: popd: directory stack empty");
|
2020-06-17 16:35:06 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool should_not_switch = false;
|
|
|
|
String path = directory_stack.take_last();
|
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
|
|
|
parser.add_option(should_not_switch, "Do not switch dirs", "no-switch", 'n');
|
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
bool should_switch = !should_not_switch;
|
|
|
|
|
|
|
|
// When no arguments are given, popd removes the top directory from the stack and performs a cd to the new top directory.
|
|
|
|
if (argc == 1) {
|
|
|
|
int rc = chdir(path.characters());
|
|
|
|
if (rc < 0) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("chdir({}) failed: {}", path, strerror(errno));
|
2020-06-17 16:35:06 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
cwd = path;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
LexicalPath lexical_path(path.characters());
|
|
|
|
if (!lexical_path.is_valid()) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("LexicalPath failed to canonicalize '{}'", path);
|
2020-06-17 16:35:06 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char* real_path = lexical_path.string().characters();
|
|
|
|
|
|
|
|
struct stat st;
|
|
|
|
int rc = stat(real_path, &st);
|
|
|
|
if (rc < 0) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("stat({}) failed: {}", real_path, strerror(errno));
|
2020-06-17 16:35:06 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!S_ISDIR(st.st_mode)) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("Not a directory: {}", real_path);
|
2020-06-17 16:35:06 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (should_switch) {
|
|
|
|
int rc = chdir(real_path);
|
|
|
|
if (rc < 0) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("chdir({}) failed: {}", real_path, strerror(errno));
|
2020-06-17 16:35:06 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
cwd = lexical_path.string();
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Shell::builtin_pushd(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
StringBuilder path_builder;
|
|
|
|
bool should_switch = true;
|
|
|
|
|
|
|
|
// From the BASH reference manual: https://www.gnu.org/software/bash/manual/html_node/Directory-Stack-Builtins.html
|
|
|
|
// With no arguments, pushd exchanges the top two directories and makes the new top the current directory.
|
|
|
|
if (argc == 1) {
|
|
|
|
if (directory_stack.size() < 2) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("pushd: no other directory");
|
2020-06-17 16:35:06 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
String dir1 = directory_stack.take_first();
|
|
|
|
String dir2 = directory_stack.take_first();
|
|
|
|
directory_stack.insert(0, dir2);
|
|
|
|
directory_stack.insert(1, dir1);
|
|
|
|
|
|
|
|
int rc = chdir(dir2.characters());
|
|
|
|
if (rc < 0) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("chdir({}) failed: {}", dir2, strerror(errno));
|
2020-06-17 16:35:06 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
cwd = dir2;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Let's assume the user's typed in 'pushd <dir>'
|
|
|
|
if (argc == 2) {
|
|
|
|
directory_stack.append(cwd.characters());
|
|
|
|
if (argv[1][0] == '/') {
|
|
|
|
path_builder.append(argv[1]);
|
|
|
|
} else {
|
2021-05-07 21:45:21 +03:00
|
|
|
path_builder.appendff("{}/{}", cwd, argv[1]);
|
2020-06-17 16:35:06 +03:00
|
|
|
}
|
|
|
|
} else if (argc == 3) {
|
|
|
|
directory_stack.append(cwd.characters());
|
|
|
|
for (int i = 1; i < argc; i++) {
|
|
|
|
const char* arg = argv[i];
|
|
|
|
|
|
|
|
if (arg[0] != '-') {
|
|
|
|
if (arg[0] == '/') {
|
|
|
|
path_builder.append(arg);
|
|
|
|
} else
|
2021-05-07 21:45:21 +03:00
|
|
|
path_builder.appendff("{}/{}", cwd, arg);
|
2020-06-17 16:35:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(arg, "-n"))
|
|
|
|
should_switch = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
LexicalPath lexical_path(path_builder.to_string());
|
|
|
|
if (!lexical_path.is_valid()) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("LexicalPath failed to canonicalize '{}'", path_builder.string_view());
|
2020-06-17 16:35:06 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char* real_path = lexical_path.string().characters();
|
|
|
|
|
|
|
|
struct stat st;
|
|
|
|
int rc = stat(real_path, &st);
|
|
|
|
if (rc < 0) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("stat({}) failed: {}", real_path, strerror(errno));
|
2020-06-17 16:35:06 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!S_ISDIR(st.st_mode)) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("Not a directory: {}", real_path);
|
2020-06-17 16:35:06 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (should_switch) {
|
|
|
|
int rc = chdir(real_path);
|
|
|
|
if (rc < 0) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("chdir({}) failed: {}", real_path, strerror(errno));
|
2020-06-17 16:35:06 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
cwd = lexical_path.string();
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Shell::builtin_pwd(int, const char**)
|
|
|
|
{
|
|
|
|
print_path(cwd);
|
|
|
|
fputc('\n', stdout);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-06-29 04:52:58 +03:00
|
|
|
int Shell::builtin_setopt(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
if (argc == 1) {
|
|
|
|
#define __ENUMERATE_SHELL_OPTION(name, default_, description) \
|
|
|
|
if (options.name) \
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("{}", #name);
|
2020-06-29 04:52:58 +03:00
|
|
|
|
|
|
|
ENUMERATE_SHELL_OPTIONS();
|
|
|
|
|
|
|
|
#undef __ENUMERATE_SHELL_OPTION
|
|
|
|
}
|
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
|
|
|
#define __ENUMERATE_SHELL_OPTION(name, default_, description) \
|
|
|
|
bool name = false; \
|
|
|
|
bool not_##name = false; \
|
|
|
|
parser.add_option(name, "Enable: " description, #name, '\0'); \
|
|
|
|
parser.add_option(not_##name, "Disable: " description, "no_" #name, '\0');
|
|
|
|
|
|
|
|
ENUMERATE_SHELL_OPTIONS();
|
|
|
|
|
|
|
|
#undef __ENUMERATE_SHELL_OPTION
|
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
#define __ENUMERATE_SHELL_OPTION(name, default_, description) \
|
|
|
|
if (name) \
|
|
|
|
options.name = true; \
|
|
|
|
if (not_##name) \
|
|
|
|
options.name = false;
|
|
|
|
|
|
|
|
ENUMERATE_SHELL_OPTIONS();
|
|
|
|
|
|
|
|
#undef __ENUMERATE_SHELL_OPTION
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-08-04 07:57:25 +03:00
|
|
|
int Shell::builtin_shift(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
int count = 1;
|
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
|
|
|
parser.add_positional_argument(count, "Shift count", "count", Core::ArgsParser::Required::No);
|
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (count < 1)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
auto argv_ = lookup_local_variable("ARGV");
|
|
|
|
if (!argv_) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("shift: ARGV is unset");
|
2020-08-04 07:57:25 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!argv_->is_list())
|
2021-04-23 17:46:57 +03:00
|
|
|
argv_ = adopt_ref(*new AST::ListValue({ argv_.release_nonnull() }));
|
2020-08-04 07:57:25 +03:00
|
|
|
|
|
|
|
auto& values = static_cast<AST::ListValue*>(argv_.ptr())->values();
|
|
|
|
if ((size_t)count > values.size()) {
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("shift: shift count must not be greater than {}", values.size());
|
2020-08-04 07:57:25 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto i = 0; i < count; ++i)
|
|
|
|
values.take_first();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-01-03 12:09:27 +03:00
|
|
|
int Shell::builtin_source(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
const char* file_to_source = nullptr;
|
|
|
|
Vector<const char*> args;
|
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
|
|
|
parser.add_positional_argument(file_to_source, "File to read commands from", "path");
|
|
|
|
parser.add_positional_argument(args, "ARGV for the sourced file", "args", Core::ArgsParser::Required::No);
|
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv)))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
Vector<String> string_argv;
|
|
|
|
for (auto& arg : args)
|
|
|
|
string_argv.append(arg);
|
|
|
|
|
|
|
|
auto previous_argv = lookup_local_variable("ARGV");
|
|
|
|
ScopeGuard guard { [&] {
|
|
|
|
if (!args.is_empty())
|
|
|
|
set_local_variable("ARGV", move(previous_argv));
|
|
|
|
} };
|
|
|
|
|
|
|
|
if (!args.is_empty())
|
|
|
|
set_local_variable("ARGV", AST::create<AST::ListValue>(move(string_argv)));
|
|
|
|
|
|
|
|
if (!run_file(file_to_source, true))
|
|
|
|
return 126;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-06-17 16:35:06 +03:00
|
|
|
int Shell::builtin_time(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
Vector<const char*> args;
|
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
|
|
|
parser.add_positional_argument(args, "Command to execute with arguments", "command", Core::ArgsParser::Required::Yes);
|
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
2020-06-19 15:02:19 +03:00
|
|
|
AST::Command command;
|
|
|
|
for (auto& arg : args)
|
|
|
|
command.argv.append(arg);
|
2020-06-17 16:35:06 +03:00
|
|
|
|
2020-07-13 08:01:28 +03:00
|
|
|
auto commands = expand_aliases({ move(command) });
|
|
|
|
|
2020-06-17 16:35:06 +03:00
|
|
|
Core::ElapsedTimer timer;
|
2020-07-13 08:01:28 +03:00
|
|
|
int exit_code = 1;
|
2020-06-17 16:35:06 +03:00
|
|
|
timer.start();
|
2020-07-13 08:01:28 +03:00
|
|
|
for (auto& job : run_commands(commands)) {
|
|
|
|
block_on_job(job);
|
2020-08-06 14:44:30 +03:00
|
|
|
exit_code = job.exit_code();
|
2020-07-13 08:01:28 +03:00
|
|
|
}
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("Time: {} ms", timer.elapsed());
|
2020-07-13 08:01:28 +03:00
|
|
|
return exit_code;
|
2020-06-17 16:35:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
int Shell::builtin_umask(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
const char* mask_text = nullptr;
|
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
|
|
|
parser.add_positional_argument(mask_text, "New mask (omit to get current mask)", "octal-mask", Core::ArgsParser::Required::No);
|
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (!mask_text) {
|
|
|
|
mode_t old_mask = umask(0);
|
|
|
|
printf("%#o\n", old_mask);
|
|
|
|
umask(old_mask);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned mask;
|
|
|
|
int matches = sscanf(mask_text, "%o", &mask);
|
|
|
|
if (matches == 1) {
|
|
|
|
umask(mask);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-05-02 09:57:53 +03:00
|
|
|
warnln("umask: Invalid mask '{}'", mask_text);
|
2020-06-17 16:35:06 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2020-10-26 20:00:14 +03:00
|
|
|
int Shell::builtin_wait(int argc, const char** argv)
|
|
|
|
{
|
2021-04-23 16:56:27 +03:00
|
|
|
Vector<int> job_ids;
|
|
|
|
Vector<bool> id_is_pid;
|
2020-10-26 20:00:14 +03:00
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
2021-04-23 16:56:27 +03:00
|
|
|
parser.add_positional_argument(Core::ArgsParser::Arg {
|
|
|
|
.help_string = "Job IDs or Jobspecs to wait for",
|
|
|
|
.name = "job-id",
|
|
|
|
.min_values = 0,
|
|
|
|
.max_values = INT_MAX,
|
|
|
|
.accept_value = [&](const String& value) -> bool {
|
|
|
|
// Check if it's a pid (i.e. literal integer)
|
|
|
|
if (auto number = value.to_uint(); number.has_value()) {
|
|
|
|
job_ids.append(number.value());
|
|
|
|
id_is_pid.append(true);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if it's a jobspec
|
|
|
|
if (auto id = resolve_job_spec(value); id.has_value()) {
|
|
|
|
job_ids.append(id.value());
|
|
|
|
id_is_pid.append(false);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
} });
|
2020-10-26 20:00:14 +03:00
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
Vector<NonnullRefPtr<Job>> jobs_to_wait_for;
|
|
|
|
|
2021-04-23 16:56:27 +03:00
|
|
|
for (size_t i = 0; i < job_ids.size(); ++i) {
|
|
|
|
auto id = job_ids[i];
|
|
|
|
auto is_pid = id_is_pid[i];
|
|
|
|
auto job = find_job(id, is_pid);
|
|
|
|
if (!job)
|
|
|
|
warnln("wait: Job with id/pid {} not found", id);
|
|
|
|
else
|
|
|
|
jobs_to_wait_for.append(*job);
|
|
|
|
}
|
|
|
|
|
2020-10-26 20:00:14 +03:00
|
|
|
if (job_ids.is_empty()) {
|
2021-04-23 16:56:27 +03:00
|
|
|
for (const auto& it : jobs)
|
2020-10-26 20:00:14 +03:00
|
|
|
jobs_to_wait_for.append(it.value);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto& job : jobs_to_wait_for) {
|
|
|
|
job->set_running_in_background(false);
|
|
|
|
block_on_job(job);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-06-17 16:35:06 +03:00
|
|
|
int Shell::builtin_unset(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
Vector<const char*> vars;
|
|
|
|
|
|
|
|
Core::ArgsParser parser;
|
|
|
|
parser.add_positional_argument(vars, "List of variables", "variables", Core::ArgsParser::Required::Yes);
|
|
|
|
|
|
|
|
if (!parser.parse(argc, const_cast<char**>(argv), false))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
for (auto& value : vars) {
|
|
|
|
if (lookup_local_variable(value)) {
|
|
|
|
unset_local_variable(value);
|
|
|
|
} else {
|
|
|
|
unsetenv(value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-01-18 09:35:00 +03:00
|
|
|
int Shell::builtin_not(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
// FIXME: Use ArgsParser when it can collect unrelated -arguments too.
|
|
|
|
if (argc == 1)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
AST::Command command;
|
|
|
|
for (size_t i = 1; i < (size_t)argc; ++i)
|
|
|
|
command.argv.append(argv[i]);
|
|
|
|
|
|
|
|
auto commands = expand_aliases({ move(command) });
|
|
|
|
int exit_code = 1;
|
2021-03-07 09:25:02 +03:00
|
|
|
auto found_a_job = false;
|
2021-01-18 09:35:00 +03:00
|
|
|
for (auto& job : run_commands(commands)) {
|
2021-03-07 09:25:02 +03:00
|
|
|
found_a_job = true;
|
2021-01-18 09:35:00 +03:00
|
|
|
block_on_job(job);
|
|
|
|
exit_code = job.exit_code();
|
|
|
|
}
|
2021-03-07 09:25:02 +03:00
|
|
|
// In case it was a function.
|
|
|
|
if (!found_a_job)
|
|
|
|
exit_code = last_return_code;
|
2021-01-18 09:35:00 +03:00
|
|
|
return exit_code == 0 ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
2021-04-23 17:39:13 +03:00
|
|
|
int Shell::builtin_kill(int argc, const char** argv)
|
|
|
|
{
|
|
|
|
// Simply translate the arguments and pass them to `kill'
|
|
|
|
Vector<String> replaced_values;
|
|
|
|
auto kill_path = find_in_path("kill");
|
|
|
|
if (kill_path.is_empty()) {
|
|
|
|
warnln("kill: `kill' not found in PATH");
|
|
|
|
return 126;
|
|
|
|
}
|
|
|
|
replaced_values.append(kill_path);
|
|
|
|
for (auto i = 1; i < argc; ++i) {
|
|
|
|
if (auto job_id = resolve_job_spec(argv[i]); job_id.has_value()) {
|
|
|
|
auto job = find_job(job_id.value());
|
|
|
|
if (job) {
|
|
|
|
replaced_values.append(String::number(job->pid()));
|
|
|
|
} else {
|
|
|
|
warnln("kill: Job with pid {} not found", job_id.value());
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
replaced_values.append(argv[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now just run `kill'
|
|
|
|
AST::Command command;
|
|
|
|
command.argv = move(replaced_values);
|
|
|
|
command.position = m_source_position.has_value() ? m_source_position->position : Optional<AST::Position> {};
|
|
|
|
|
|
|
|
auto exit_code = 1;
|
|
|
|
if (auto job = run_command(command)) {
|
|
|
|
block_on_job(job);
|
|
|
|
exit_code = job->exit_code();
|
|
|
|
}
|
|
|
|
return exit_code;
|
|
|
|
}
|
|
|
|
|
2020-08-14 21:00:48 +03:00
|
|
|
bool Shell::run_builtin(const AST::Command& command, const NonnullRefPtrVector<AST::Rewiring>& rewirings, int& retval)
|
2020-06-17 16:35:06 +03:00
|
|
|
{
|
2020-08-14 21:00:48 +03:00
|
|
|
if (command.argv.is_empty())
|
2020-06-17 16:35:06 +03:00
|
|
|
return false;
|
|
|
|
|
2020-08-14 21:00:48 +03:00
|
|
|
if (!has_builtin(command.argv.first()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Vector<const char*> argv;
|
|
|
|
for (auto& arg : command.argv)
|
|
|
|
argv.append(arg.characters());
|
|
|
|
|
|
|
|
argv.append(nullptr);
|
|
|
|
|
|
|
|
StringView name = command.argv.first();
|
|
|
|
|
|
|
|
SavedFileDescriptors fds { rewirings };
|
2020-06-17 16:35:06 +03:00
|
|
|
|
2020-08-14 21:00:48 +03:00
|
|
|
for (auto& rewiring : rewirings) {
|
2020-10-27 21:08:37 +03:00
|
|
|
int rc = dup2(rewiring.old_fd, rewiring.new_fd);
|
2020-08-14 21:00:48 +03:00
|
|
|
if (rc < 0) {
|
|
|
|
perror("dup2(run)");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-07 19:07:04 +03:00
|
|
|
Core::EventLoop loop;
|
|
|
|
setup_signals();
|
|
|
|
|
2021-01-03 12:08:20 +03:00
|
|
|
#define __ENUMERATE_SHELL_BUILTIN(builtin) \
|
|
|
|
if (name == #builtin) { \
|
|
|
|
retval = builtin_##builtin(argv.size() - 1, argv.data()); \
|
|
|
|
if (!has_error(ShellError::None)) \
|
|
|
|
raise_error(m_error, m_error_description, command.position); \
|
2021-04-12 22:35:43 +03:00
|
|
|
fflush(stdout); \
|
|
|
|
fflush(stderr); \
|
2021-01-03 12:08:20 +03:00
|
|
|
return true; \
|
2020-06-17 16:35:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
ENUMERATE_SHELL_BUILTINS();
|
|
|
|
|
|
|
|
#undef __ENUMERATE_SHELL_BUILTIN
|
|
|
|
return false;
|
|
|
|
}
|
2020-06-29 04:56:06 +03:00
|
|
|
|
|
|
|
bool Shell::has_builtin(const StringView& name) const
|
|
|
|
{
|
|
|
|
#define __ENUMERATE_SHELL_BUILTIN(builtin) \
|
|
|
|
if (name == #builtin) { \
|
|
|
|
return true; \
|
|
|
|
}
|
|
|
|
|
|
|
|
ENUMERATE_SHELL_BUILTINS();
|
|
|
|
|
|
|
|
#undef __ENUMERATE_SHELL_BUILTIN
|
|
|
|
return false;
|
|
|
|
}
|
2020-10-01 17:43:01 +03:00
|
|
|
|
|
|
|
}
|