/* Send messages to selected processes Copyright (C) 1998,99,2000,02 Free Software Foundation, Inc. Written by Jose M. Moya This file is part of the GNU Hurd. The GNU Hurd 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, or (at your option) any later version. The GNU Hurd 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 this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. */ #include #include #include #include #include #include #include #include #include #include "pids.h" #include /* From libc (not in hurd.h) */ char * _hurd_canonicalize_directory_name_internal (file_t thisdir, char *buf, size_t size); const char *argp_program_version = STANDARD_HURD_VERSION (msgport); static const struct argp_option options[] = { {0, 0} }; static const char doc[] = "Send messages to selected processes"; static const char args_doc[] = ""; /* All command functions match this prototype. */ typedef error_t (*cmd_func_t) (pid_t pid, mach_port_t msgport, int argc, char *argv[]); /* One of these is created for each command given in the command line. */ typedef struct cmd { /* Function to execute for this command */ cmd_func_t f; /* Array of arguments that will be passed to function F */ char **args; size_t num_args; } cmd_t; /* Execute command CMD on process PID */ error_t do_cmd (pid_t pid, cmd_t cmd) { error_t err; mach_port_t msgport; process_t proc = getproc (); /* Get a msgport for PID, to which we can send requests. */ err = proc_getmsgport (proc, pid, &msgport); if (err) error (1, err, "%d: Cannot get process msgport", pid); err = (*cmd.f) (pid, msgport, cmd.num_args, cmd.args); if (err) error (2, err, "%d: Cannot execute command", pid); mach_port_deallocate (mach_task_self (), msgport); return 0; } /* All these functions, whose name start with cmd_, execute some commands on the process PID, by sending messages (see msg.defs) to its message port, which is MSGPORT. ARGC and ARGV are as in main. They return zero iff successful. */ /* Print the name and value of the environment variable ARGV[0]. Without arguments (ARGC==0), print the names and values of all environment variables. */ error_t cmd_getenv (pid_t pid, mach_port_t msgport, int argc, char *argv[]) { error_t err; /* Memory will be vm_allocated by msg_get_* if the result does not fit in buf. */ char buf[1024], *data = buf; mach_msg_type_number_t len = sizeof (buf); if (argc) { err = msg_get_env_variable (msgport, argv[0], &data, &len); if (err) return err; printf ("%d: %s=%s\n", pid, argv[0], data); } else /* get the whole environment */ { char *p; err = msg_get_environment (msgport, &data, &len); if (err) return err; for (p=data; p < data + len; p = strchr (p, '\0') + 1) printf ("%d: %s\n", pid, p); } if (data != buf) munmap (data, len); return err; } /* Set environment variable ARGV[0] to the value ARGV[1]. */ error_t cmd_setenv (pid_t pid, mach_port_t msgport, int argc, char *argv[]) { error_t err; task_t task; process_t proc = getproc (); err = proc_pid2task (proc, pid, &task); if (err) return err; err = msg_set_env_variable (msgport, task, argv[0], argv[1], 1); mach_port_deallocate (mach_task_self (), task); return err; } /* Clear environment. */ error_t cmd_clearenv (pid_t pid, mach_port_t msgport, int argc, char *argv[]) { error_t err; task_t task; process_t proc = getproc (); err = proc_pid2task (proc, pid, &task); if (err) return err; err = msg_set_environment (msgport, task, 0, 0); mach_port_deallocate (mach_task_self (), task); return err; } /* Convert string STR in flags for file access modes. STR should be a combination of `r', `w' and `x' (for read, write and execute modes respectively). Other chars are ignored. */ static inline int str2flags (const char *str) { int flags = 0; while (*str) { switch (*str) { case 'r': flags |= O_RDONLY; break; case 'w': flags |= O_WRONLY|O_CREAT; break; case 'x': flags |= O_EXEC; break; case 'a': flags |= O_APPEND; break; default: /* ignore */ break; } ++str; } return flags; } /* Set port associated to file descriptor FD of process PID, whose message port is MSGPORT, to FILE. Used by cmd_{setfd,stdin,stdout,stderr}. */ error_t do_setfd (pid_t pid, mach_port_t msgport, size_t fd, file_t file) { error_t err; task_t task; process_t proc = getproc (); err = proc_pid2task (proc, pid, &task); if (err) return err; err = msg_set_fd (msgport, task, fd, file, MACH_MSG_TYPE_COPY_SEND); mach_port_deallocate (mach_task_self (), file); mach_port_deallocate (mach_task_self (), task); return err; } /* Set port associated to file descriptor ARGV[0] to the file ARGV[1]. File access mode is given by ARGV[2] (see str2flags). If no access mode is given, the default is O_RDONLY. */ error_t cmd_setfd (pid_t pid, mach_port_t msgport, int argc, char *argv[]) { error_t err; int flags = str2flags (argc > 2 ? argv[2] : "r"); file_t file = file_name_lookup (argv[1], flags, 0666); if (file == MACH_PORT_NULL) return errno; err = do_setfd (pid, msgport, atoi (argv[0]), file); if (err) mach_port_deallocate (mach_task_self (), file); return err; } /* Set standard input to ARGV[0]. Optionally, ARGV[1] may specify the file access mode (see str2flags). The default is O_RDONLY */ error_t cmd_stdin (pid_t pid, mach_port_t msgport, int argc, char *argv[]) { error_t err; int flags = str2flags (argc > 2 ? argv[2] : "r"); file_t file = file_name_lookup (argv[0], flags, 0666); if (file == MACH_PORT_NULL) return errno; err = do_setfd (pid, msgport, STDIN_FILENO, file); if (err) mach_port_deallocate (mach_task_self (), file); return err; } /* Set standard output to ARGV[0]. Optionally, ARGV[1] may specify the file access mode (see str2flags). The default is O_WRONLY */ error_t cmd_stdout (pid_t pid, mach_port_t msgport, int argc, char *argv[]) { error_t err; int flags = str2flags (argc > 2 ? argv[2] : "w"); file_t file = file_name_lookup (argv[0], flags, 0666); if (file == MACH_PORT_NULL) return errno; err = do_setfd (pid, msgport, STDOUT_FILENO, file); if (err) mach_port_deallocate (mach_task_self (), file); return err; } /* Set standard error to ARGV[0]. Optionally, ARGV[1] may specify the file access mode (see str2flags). The default is O_RDONLY */ error_t cmd_stderr (pid_t pid, mach_port_t msgport, int argc, char *argv[]) { error_t err; int flags = str2flags (argc > 2 ? argv[2] : "w"); file_t file = file_name_lookup (argv[0], flags, 0666); if (file == MACH_PORT_NULL) return errno; err = do_setfd (pid, msgport, STDERR_FILENO, file); if (err) mach_port_deallocate (mach_task_self (), file); return err; } /* Change current working directory to ARGV[0]. */ error_t cmd_chcwdir (pid_t pid, mach_port_t msgport, int argc, char *argv[]) { error_t err; file_t dir; task_t task; process_t proc = getproc (); dir = file_name_lookup (argv[0], 0, 0); if (dir == MACH_PORT_NULL) return errno; err = proc_pid2task (proc, pid, &task); if (err) { mach_port_deallocate (mach_task_self (), dir); return err; } err = msg_set_init_port (msgport, task, INIT_PORT_CWDIR, dir, MACH_MSG_TYPE_COPY_SEND); mach_port_deallocate (mach_task_self (), dir); mach_port_deallocate (mach_task_self (), task); return err; } /* Change current working directory to current root directory. */ error_t cmd_cdroot (pid_t pid, mach_port_t msgport, int argc, char *argv[]) { error_t err; file_t dir; task_t task; process_t proc = getproc (); err = proc_pid2task (proc, pid, &task); if (err) return err; err = msg_get_init_port (msgport, task, INIT_PORT_CRDIR, &dir); if (err) { mach_port_deallocate (mach_task_self (), task); return err; } err = msg_set_init_port (msgport, task, INIT_PORT_CWDIR, dir, MACH_MSG_TYPE_COPY_SEND); mach_port_deallocate (mach_task_self (), dir); mach_port_deallocate (mach_task_self (), task); return err; } /* Change current root directory to ARGV[0]. */ error_t cmd_chcrdir (pid_t pid, mach_port_t msgport, int argc, char *argv[]) { error_t err; file_t dir; task_t task; process_t proc = getproc (); dir = file_name_lookup (argv[0], 0, 0); if (dir == MACH_PORT_NULL) return errno; err = proc_pid2task (proc, pid, &task); if (err) { mach_port_deallocate (mach_task_self (), dir); return err; } err = msg_set_init_port (msgport, task, INIT_PORT_CRDIR, dir, MACH_MSG_TYPE_COPY_SEND); mach_port_deallocate (mach_task_self (), dir); mach_port_deallocate (mach_task_self (), task); return err; } /* Print current working directory. */ error_t cmd_pwd (pid_t pid, mach_port_t msgport, int argc, char *argv[]) { error_t err; file_t dir; task_t task; process_t proc = getproc (); err = proc_pid2task (proc, pid, &task); if (err) return err; err = msg_get_init_port (msgport, task, INIT_PORT_CWDIR, &dir); if (err) { mach_port_deallocate (mach_task_self (), task); return err; } printf ("%d: %s\n", pid, _hurd_canonicalize_directory_name_internal(dir, NULL, 0)); mach_port_deallocate (mach_task_self (), dir); mach_port_deallocate (mach_task_self (), task); return 0; } /* Print current root directory */ error_t cmd_getroot (pid_t pid, mach_port_t msgport, int argc, char *argv[]) { error_t err; file_t dir; task_t task; process_t proc = getproc (); err = proc_pid2task (proc, pid, &task); if (err) return err; err = msg_get_init_port (msgport, task, INIT_PORT_CRDIR, &dir); if (err) { mach_port_deallocate (mach_task_self (), task); return err; } printf ("%d: %s\n", pid, _hurd_canonicalize_directory_name_internal(dir, NULL, 0)); mach_port_deallocate (mach_task_self (), dir); mach_port_deallocate (mach_task_self (), task); return 0; } /* Change umask to ARGV[0] (octal value). Without arguments, print the value of current umask. */ error_t cmd_umask (pid_t pid, mach_port_t msgport, int argc, char *argv[]) { error_t err; mode_t umask; task_t task; process_t proc = getproc (); err = proc_pid2task (proc, pid, &task); if (err) return err; if (argc) { umask = strtol(argv[0], 0, 8); err = msg_set_init_int (msgport, task, INIT_UMASK, umask); } else { err = msg_get_init_int (msgport, task, INIT_UMASK, &umask); if (!err) printf ("%d: %03o\n", pid, umask); } mach_port_deallocate (mach_task_self (), task); return err; } #define OA OPTION_ARG_OPTIONAL #define CMD_GETENV 1000 #define CMD_SETENV 1001 #define CMD_CLRENV 1002 #define CMD_CHCWDIR 1003 #define CMD_CHCRDIR 1004 #define CMD_CDROOT 1005 #define CMD_UMASK 1006 #define CMD_SETFD 1007 #define CMD_STDIN 1008 #define CMD_STDOUT 1009 #define CMD_STDERR 1010 #define CMD_PWD 1011 #define CMD_GETROOT 1012 /* Params to be passed as the input when parsing CMDS_ARGP. */ struct cmds_argp_params { /* Array to be extended with parsed cmds. */ cmd_t **cmds; size_t *num_cmds; }; static const struct argp_option cmd_options[] = { {"getenv", CMD_GETENV, "VAR", OA, "Get environment variable"}, {"printenv", 0, 0, OPTION_ALIAS}, {"setenv", CMD_SETENV, "VAR VALUE", 0, "Set environment variable"}, {"clearenv", CMD_CLRENV, 0, 0, "Clear environment"}, {"pwd", CMD_PWD, 0, 0, "Print current working directory"}, {"getcwd", 0, 0, OPTION_ALIAS}, {"getroot", CMD_GETROOT,0, 0, "Print current root directory"}, {"setfd", CMD_SETFD, "FD FILE [rwxa]", 0, "Change file descriptor"}, {"stdin", CMD_STDIN, "FILE [rwxa]", 0, "Change standard input"}, {"stdout", CMD_STDOUT, "FILE [rwxa]", 0, "Change standard output"}, {"stderr", CMD_STDERR, "FILE [rwxa]", 0, "Change standard error"}, {"chdir", CMD_CHCWDIR,"DIR", 0, "Change current working directory"}, {"cd", 0, 0, OPTION_ALIAS}, {"chroot", CMD_CHCRDIR,"DIR", 0, "Change current root directory"}, {"cdroot", CMD_CDROOT, 0, 0, "Change cwd to root directory"}, {"umask", CMD_UMASK, "MASK", OA, "Change umask"}, {0, 0} }; /* Add a new command to the array of commands already parsed reallocating it in malloced memory. FUNC is the command function. MINARGS and MAXARGS are the minimum and maximum number of arguments the parser will accept for this command. Further checking of the arguments should be done in FUNC. ARG is the next argument in the command line (probably the first argument for this command). STATE is the argp parser state as used in parse_cmd_opt. */ static error_t add_cmd (cmd_func_t func, size_t minargs, size_t maxargs, char *arg, struct argp_state *state) { cmd_t *cmd; size_t i = 0; struct cmds_argp_params *params = state->input; size_t num_cmds = *params->num_cmds + 1; cmd_t *cmds = realloc (*params->cmds, num_cmds * sizeof(cmd_t)); *params->cmds = cmds; *params->num_cmds = num_cmds; cmd = &cmds[num_cmds-1]; cmd->f = func; cmd->args = 0; if (maxargs) { cmd->args = malloc (maxargs * sizeof (char *)); if (arg) cmd->args[i++] = arg; while (i < maxargs && state->argv[state->next] && state->argv[state->next][0] != '-') cmd->args[i++] = state->argv[state->next++]; } if (i < minargs || i > maxargs) argp_usage(state); cmd->num_args = i; return 0; } /* Parse one option/arg for the argp parser cmds_argp (see argp.h). */ static error_t parse_cmd_opt (int key, char *arg, struct argp_state *state) { /* A buffer used for rewriting command line arguments without dashes for the parser to understand them. It gets realloced for each successive arg that needs it, on the assumption that args don't get parsed multiple times. */ static char *arg_hack_buf = 0; switch (key) { case ARGP_KEY_ARG: /* Non-option argument. */ if (!isdigit (*arg) && !state->quoted) { /* Make state->next point to the just parsed argument to re-parse it with 2 dashes prepended. */ size_t len = strlen (arg) + 1; arg_hack_buf = realloc (arg_hack_buf, 2 + len); state->argv[--state->next] = arg_hack_buf; state->argv[state->next][0] = '-'; state->argv[state->next][1] = '-'; memcpy (&state->argv[state->next][2], arg, len); break; } else return ARGP_ERR_UNKNOWN; case CMD_CHCWDIR: add_cmd (&cmd_chcwdir, 0, 1, arg, state); break; case CMD_CHCRDIR: add_cmd (&cmd_chcrdir, 1, 1, arg, state); break; case CMD_CDROOT: add_cmd (&cmd_cdroot, 0, 0, arg, state); break; case CMD_PWD: add_cmd (&cmd_pwd, 0, 0, arg, state); break; case CMD_GETROOT: add_cmd (&cmd_getroot, 0, 0, arg, state); break; case CMD_UMASK: add_cmd (&cmd_umask, 0, 1, arg, state); break; case CMD_GETENV: add_cmd (&cmd_getenv, 0, 1, arg, state); break; case CMD_SETENV: add_cmd (&cmd_setenv, 2, 2, arg, state); break; case CMD_CLRENV: add_cmd (&cmd_clearenv, 0, 0, arg, state); break; case CMD_SETFD: add_cmd (&cmd_setfd, 2, 3, arg, state); break; case CMD_STDIN: add_cmd (&cmd_stdin, 1, 2, arg, state); break; case CMD_STDOUT: add_cmd (&cmd_stdout, 1, 2, arg, state); break; case CMD_STDERR: add_cmd (&cmd_stderr, 1, 2, arg, state); break; default: return ARGP_ERR_UNKNOWN; } return 0; } /* Filtering of help output strings for cmds_argp parser. Return a malloced replacement for TEXT as the arguments doc string. See argp.h for details. */ static char * help_filter (int key, const char *text, void *input) { if (key == ARGP_KEY_HELP_ARGS_DOC) return strdup ("CMD [ARG...]"); return (char *)text; } /* An argp parser for selecting a command (see argp.h). */ struct argp cmds_argp = { cmd_options, parse_cmd_opt, 0, 0, 0, help_filter }; int main(int argc, char *argv[]) { cmd_t *cmds = 0; size_t num_cmds = 0; struct cmds_argp_params cmds_argp_params = { &cmds, &num_cmds }; pid_t *pids = 0; /* User-specified pids. */ size_t num_pids = 0; struct pids_argp_params pids_argp_params = { &pids, &num_pids, 0 }; error_t parse_opt (int key, char *arg, struct argp_state *state) { switch (key) { case ARGP_KEY_INIT: /* Initialize inputs for child parsers. */ state->child_inputs[0] = &cmds_argp_params; state->child_inputs[1] = &pids_argp_params; break; case ARGP_KEY_NO_ARGS: if (!num_cmds || !num_pids) argp_usage (state); break; default: return ARGP_ERR_UNKNOWN; } return 0; } struct argp_child argp_kids[] = { { &cmds_argp, 0, "Commands:", 2}, { &pids_argp, 0, "Process selection:", 3}, {0} }; struct argp argp = { options, parse_opt, args_doc, doc, argp_kids }; error_t err; pid_t cur_pid = getpid (); pid_t pid; cmd_t cmd; size_t i, j; /* Parse our command line. This shouldn't ever return an error. */ argp_parse (&argp, argc, argv, 0, 0, 0); for (i = 0; i < num_pids; ++i) { pid = pids[i]; if (pid != cur_pid) for (j = 0; j < num_cmds; ++j) { cmd = cmds[j]; if ((err = do_cmd (pid, cmd))) error (2, err, "%d: Cannot execute command", pid); } } exit (0); }