Ticket #1944: 0001-killall-add-killall-command.patch

src/bin/coreutils/src/Jamfile

@@ -110 +110 @@
 
 BinCommand kill : kill.c operand2sig.c : libfetish.a : $(coreutils_rsrc) ;
 
+BinCommand killall : killall.c operand2sig.c : libfetish.a : $(coreutils_rsrc) ;
+
 BinCommand id : id.c group-list.c : libfetish.a : $(coreutils_rsrc) ;
 
 BinCommand groups : groups.c [ FGristFiles group-list.o ] : libfetish.a : $(coreutils_rsrc) ;

new file src/bin/coreutils/src/killall.c

@@ +1 @@
+/*
+ * killall.c - send signal to processes
+ *
+ * Copyright 2012 Haiku, Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Author:
+ *  Prasad Joshi <prasadjoshi.linux@gmail.com>
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <getopt.h>
+#include <libgen.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <regex.h>
+#include <pwd.h>
+#include <OS.h>
+
+#include "sig2str.h"
+#include "operand2sig.h"
+
+struct process {
+    pid_t   pid;
+    char    *command;
+    uid_t   uid;
+    bool    kill;
+};
+
+static bool exact   = false; // perform exact matching
+static bool ignore_case = false; // case insensitive match
+static bool interactive = false; // ask before killing
+static bool group   = false; // kill group
+static bool regex_match = false; // regular expression match
+static bool verbose = false; // print details
+static bool kill_wait   = false; // wait for processes to get killed
+static bool dry_run = false; // do not kill any process
+
+static uid_t uid;       // user id
+static char *user = NULL;   // user name
+
+static int sig_num = SIGTERM;       // signal to send
+static char sig_name[SIG2STR_MAX];  // signal in string format
+
+static char **commands = NULL;  // list of user specified processes
+
+void
+usage(const char *s)
+{
+    fprintf(stderr, "\nUsage: killall [OPTION] NAME\n\n");
+    fprintf(stderr, "\t -l,--list       display list of signals.\n");
+    fprintf(stderr, "\t -e,--exact      exact match for long names.\n");
+    fprintf(stderr, "\t -I,--ignore-case    case insensitive name match.\n");
+    fprintf(stderr, "\t -g,--process-group  kill all processes from process group.\n");
+    fprintf(stderr, "\t -y,--younger-than   kill processes created after TIME.\n");
+    fprintf(stderr, "\t -o,--older-than     kill processes created before TIME.\n");
+    fprintf(stderr, "\t -i,--interactive    confirm before killing.\n");
+    fprintf(stderr, "\t -r,--regexp         regular expression match for name.\n");
+    fprintf(stderr, "\t -s,--signal SIGNAL  send specified signal (default: SIGTERM).\n");
+    fprintf(stderr, "\t -u,--user USER      kill processes of given USER.\n");
+    fprintf(stderr, "\t -v,--verbose        Verbose output.\n");
+    fprintf(stderr, "\t -w,--wait           ensure processes are killed.\n");
+    fprintf(stderr, "\t -d,--dry-run        do not send signal.\n");
+    fprintf(stderr, "\n");
+}
+
+
+void
+free_process(struct process *procs, int no_proccesses)
+{
+    int c = no_proccesses - 1;
+    struct process *t;
+
+    for ( ; c >= 0; c--) {
+        t = &procs[c];
+        if (t && t->command)
+            free(t->command);
+    }
+    free(procs);
+}
+
+
+int
+get_response(char *sig_name, pid_t pid, bool group)
+{
+    char   *line = NULL;
+    size_t size = 0;
+    int    rc;
+
+    if (!group)
+        printf("Signal (%s) process %d? [n]: ", sig_name, pid);
+    else
+        printf("Signal (%s) group of process %d? [n]: ", sig_name, pid);
+
+    if (getline(&line, &size, stdin) < 0) {
+        fprintf(stderr, "Cannot read user input: %s", strerror(errno));
+        // TODO: treated as false response
+        return 0;
+    }
+
+    // rc would be 1 only for yes response
+    rc = rpmatch(line) <= 0? 0 : 1;
+
+    free(line);
+    return rc;
+}
+
+
+struct
+process *get_all_processes(int *no_proccesses)
+{
+    team_info tm;
+    uint32    tc;
+
+    struct process  *procs = NULL;
+    struct process  *t     = NULL;
+    int     c      = 0;
+
+    // find the process
+    tc = 0;
+    while (get_next_team_info(&tc, &tm) >= B_OK) {
+        char *p, *q;
+
+        q = tm.args;
+        p = strchr(q, ' ');
+        if (p) {
+            // we are only interested in the program name
+            *p = 0;
+        }
+
+        t = realloc((void *) procs, sizeof(*procs) * (c + 1));
+        if (!t)
+            goto error;
+
+        procs       = t;
+        t       = &procs[c];
+        t->pid      = tm.team;
+        t->command  = strdup(q);
+        t->uid      = tm.uid;
+        t->kill     = false;
+        c++;
+
+        if (!t->command)
+            goto error;
+    }
+    *no_proccesses = c;
+
+    return procs;
+error:
+    free_process(procs, c);
+    *no_proccesses = 0;
+    return NULL;
+}
+
+
+bool
+match_regex(char *name, regex_t *re_list, int regs)
+{
+    char    *r;
+    char    *s;
+    int     i;
+    regex_t *re;
+
+    r = strdup(name);
+    s = basename(r);
+
+    for (i = 0; i < regs; i++) {
+        re = &re_list[i];
+
+        if (regexec(re, s, 0, NULL, 0) != REG_NOMATCH) {
+            free(r);
+            return true;
+        }
+    }
+    free(r);
+    return false;
+}
+
+
+bool
+match_names(char *name, char **name_list, int names, bool ignore_case)
+{
+    char *r;
+    char *s;
+    int  i;
+    char *n;
+    bool rc = false;
+
+    r = strdup(name);
+    s = basename(r);
+
+    for (i = 0; i < names; i++) {
+        n = name_list[i];
+
+        if (strchr(n, '/')) {
+            struct stat s1, s2;
+            ino_t inode;
+
+            /*
+             * user specified the path of the process to kill.
+             * - find inode number of the path
+             * - find inode number of the program file
+             * - match inode number
+             */
+            if (stat(n, &s1) < 0)
+                goto out;
+
+            // inode of given path
+            inode = s1.st_ino;
+
+            // find the inode of the program running
+            if (stat(name, &s2) < 0)
+                goto out;
+
+            if (s1.st_dev == s2.st_dev && inode == s2.st_ino) {
+                rc = true;
+                break;
+            }
+
+        } else if ((ignore_case && !strcasecmp(s, n)) || !strcmp(s, n)) {
+            rc = true;
+            break;
+        }
+    }
+out:
+    free(r);
+    return rc;
+}
+
+
+int
+do_kill(struct process *p, int no_proccesses)
+{
+    int i;
+    struct process *t;
+    pid_t pid;
+    int no_killed = 0;
+
+    for (i = 0; i < no_proccesses; i++) {
+        t = &p[i];
+
+        if (!t->kill)
+            continue;
+
+        pid = t->pid;
+
+        // check for user input if needed
+        if (interactive && !get_response(sig_name, pid, group))
+            continue;
+
+        if (group)
+            pid = -pid;
+
+
+        if (verbose)
+            printf("Sending signal (%s) to process (%d).\n", sig_name, pid);
+
+        if (!dry_run && (kill(pid, sig_num) < 0)) {
+            // sending signal to this process failed
+            t->kill = false;
+            fprintf(stderr, "Signal to process (%d) failed: %s\n",
+                    t->pid, strerror(errno));
+            continue;
+        }
+
+        no_killed++;
+    }
+
+    if (verbose && no_killed)
+        printf("Sent %s to %d processes.\n", sig_name, no_killed);
+
+    if (!kill_wait)
+        return 0;
+
+    /*
+     * Wait for processes to terminate. If a process does not terminate
+     * this will hange forever.
+     */
+    while (!dry_run && no_killed) {
+        for (i = 0; i < no_proccesses; i++) {
+            t = &p[i];
+
+            if (!t->kill)
+                continue;
+
+            pid = t->pid;
+
+            // check if process is still running
+            if (kill(pid, 0) < 0) {
+                // process is killed
+                no_killed--;
+                t->kill = false;
+            }
+        }
+
+        // give other processes chance to run
+        sleep(2);
+    }
+
+    return 0;
+}
+
+
+int
+kill_all(char **cmd_list, int commands)
+{
+    int     rc = -1;
+    struct process  *procs;
+    int     no_proccesses;
+    pid_t       self_pid;
+    int         i;
+    regex_t     *re;
+    regex_t     re_list[commands];
+    int     regs;
+    struct process  *t;
+
+    // find all processes
+    procs = get_all_processes(&no_proccesses);
+    if (!procs)
+        return -1;
+
+    self_pid = getpid();
+
+    // build regular expressions
+    if (regex_match) {
+        int flag = REG_EXTENDED | REG_NOSUB;
+        if (ignore_case)
+            flag |= REG_ICASE;
+
+        for (i = 0; i < commands; i++) {
+            char *n = cmd_list[i];
+
+            re = &re_list[i];
+            rc = regcomp(re, n, flag);
+            if (rc != 0) {
+                fprintf(stderr, "Incorrect regular expression: %s\n", n);
+                goto error;
+            }
+        }
+
+        regs = commands;
+    }
+
+    // find the list of processes to be killed
+    for (i = 0; i < no_proccesses; i++) {
+        t = &procs[i];
+
+        // do not kill self
+        if (t->pid == self_pid)
+            continue;
+
+        // match uid
+        if (user && t->uid != uid)
+            continue;
+
+        if (user && !commands) {
+            // kill all processes of specified user
+            t->kill = true;
+            continue;
+        }
+
+        // match name
+        if (regex_match)
+            t->kill = match_regex(t->command, re_list, regs);
+        else
+            t->kill = match_names(t->command, cmd_list, commands, ignore_case);
+    }
+
+    do_kill(procs, no_proccesses);
+
+    if (regex_match) {
+        for (i = 0; i < commands; i++) {
+            re = &re_list[i];
+            regfree(re);
+        }
+    }
+
+    rc = 0;
+error:
+    free_process(procs, no_proccesses);
+    return rc;
+}
+
+
+void
+list_signals()
+{
+    int s;
+    char name[SIG2STR_MAX];
+
+    for (s = 1; s <= SIGNUM_BOUND; s++) {
+        if (!sig2str(s, name)) {
+            printf("%s ", name);
+        }
+    }
+    printf("\n");
+}
+
+
+int
+main(int argc, char *argv[])
+{
+    char *program;
+    char opt;
+    static struct option options[] = {
+        { "list",       no_argument,        NULL, 'l' },
+        { "ignore-case",    no_argument,        NULL, 'I' },
+        { "process-group",  no_argument,        NULL, 'g' },
+        { "interactive",    no_argument,        NULL, 'i' },
+        { "regexp",     no_argument,        NULL, 'r' },
+        { "signal",     required_argument,  NULL, 's' },
+        { "user",       required_argument,  NULL, 'u' },
+        { "verbose",        no_argument,        NULL, 'v' },
+        { "wait",       no_argument,        NULL, 'w' },
+        { "dry-run",        no_argument,        NULL, 'd' },
+        { 0,            0,          0,     0  }
+    };
+
+    program = argv[0];
+    if (argc < 2)
+        usage(NULL);
+
+    // tell getopt to not to print 'unrecognized options' error
+    opterr = 0;
+    while (1) {
+        opt = getopt_long_only(argc, argv, "lIgirs:u:vwd", options, NULL);
+
+        if (opt < 0)
+            break;
+
+        switch (opt) {
+        case 'l':
+            // display the list of signals
+            list_signals();
+            return 0;
+
+        case 'I':
+            ignore_case = true;
+            break;
+
+        case 'g':
+            group = true;
+            break;
+
+        case 'i':
+            interactive = true;
+            break;
+
+        case 'r':
+            regex_match = true;
+            break;
+
+        case 's':
+            sig_num = operand2sig(optarg, sig_name);
+            if (sig_num < 0)
+                exit(EINVAL);
+            break;
+
+        case 'u':
+        {
+            struct passwd *pw;
+
+            if (!optarg) {
+                usage(NULL);
+                exit(EINVAL);
+            }
+
+            user = strdup(optarg);
+            if (!user) {
+                fprintf(stderr, "Memory allocation failed.\n");
+                exit(ENOMEM);
+            }
+
+            pw = getpwnam(user);
+            if (!pw) {
+                fprintf(stderr, "%s is not a user.\n", user);
+                free(user);
+                exit(EINVAL);
+            }
+
+            uid = pw->pw_uid;
+
+            break;
+        }
+
+        case 'd':
+            dry_run = true;
+            break;
+
+        case 'v':
+            verbose = true;
+            break;
+
+        case 'w':
+            kill_wait = true;
+            break;
+
+        case '?':
+        {
+            char c = argv[optind - 1][1];
+            sig_num = -1;
+            if (isdigit(c) || (c >= 'A' && c <= 'Z'))
+                sig_num = operand2sig(&argv[optind - 1][1], sig_name);
+
+            if (sig_num < 0) {
+                usage(NULL);
+                exit(EINVAL);
+            }
+            break;
+        }
+        default:
+            usage(NULL);
+            exit(EINVAL);
+            break;
+
+        }
+    }
+
+    if (!argv[optind] && !user) {
+        // which process to kill?
+        usage(NULL);
+        exit(EINVAL);
+    }
+
+    if (sig_num == SIGTERM)
+        sig2str(sig_num, sig_name);
+
+    commands  = &argv[optind];
+
+    return kill_all(commands, argc - optind);
+}