/* find_pid_by_name() * * Modified by Vladimir Oleynik for use with libbb/procps.c * This finds the pid of the specified process. * Currently, it's implemented by rummaging through * the proc filesystem. * * Returns a list of all matching PIDs * It is the caller's duty to free the returned pidlist. */ pid_t* find_pid_by_name(const char* procName) { pid_t* pidList; int i = 0; procps_status_t* p = NULL; pidList = xmalloc(sizeof(*pidList)); while ((p = procps_scan(p, PSSCAN_PID|PSSCAN_COMM|PSSCAN_ARGV0))) { if ( /* we require comm to match and to not be truncated */ /* in Linux, if comm is 15 chars, it may be a truncated * name, so we don't allow that to match */ (!p->comm[sizeof(p->comm)-2] && strcmp(p->comm, procName) == 0) /* or we require argv0 to match (essential for matching reexeced /proc/self/exe)*/ || (p->argv0 && strcmp(bb_basename(p->argv0), procName) == 0) /* TOOD: we can also try /proc/NUM/exe link, do we want that? */ ) { pidList = xrealloc(pidList, sizeof(*pidList) * (i+2)); pidList[i++] = p->pid; } } pidList[i] = 0; return pidList; }
/* find_pid_by_name() * * Modified by Vladimir Oleynik for use with libbb/procps.c * This finds the pid of the specified process. * Currently, it's implemented by rummaging through * the proc filesystem. * * Returns a list of all matching PIDs */ extern long* find_pid_by_name( const char* pidName) { long* pidList; int i=0; procps_status_t * p; pidList = xmalloc(sizeof(long)); #ifdef CONFIG_SELINUX while ((p = procps_scan(0, 0, NULL)) != 0) { #else while ((p = procps_scan(0)) != 0) { #endif if (strcmp(p->short_cmd, pidName) == 0) { pidList=xrealloc( pidList, sizeof(long) * (i+2)); pidList[i++]=p->pid; } } pidList[i] = i==0 ? -1 : 0; return pidList; }
/* find_pid_by_name() * * Modified by Vladimir Oleynik for use with libbb/procps.c * This finds the pid of the specified process. * Currently, it's implemented by rummaging through * the proc filesystem. * * Returns a list of all matching PIDs * It is the caller's duty to free the returned pidlist. */ extern long* find_pid_by_name( const char* pidName) { long* pidList; int i=0; procps_status_t * p; pidList = xmalloc(sizeof(long)); while ((p = procps_scan(0)) != 0) { if (strncmp(p->short_cmd, pidName, COMM_LEN-1) == 0) { pidList=xrealloc( pidList, sizeof(long) * (i+2)); pidList[i++]=p->pid; } } pidList[i] = i==0 ? -1 : 0; return pidList; }
/* This finds the pid of the specified process. * Currently, it's implemented by rummaging through * the proc filesystem. * * Returns a list of all matching PIDs * It is the caller's duty to free the returned pidlist. * * Modified by Vladimir Oleynik for use with libbb/procps.c */ pid_t* FAST_FUNC find_pid_by_name(const char *procName) { pid_t* pidList; int i = 0; procps_status_t* p = NULL; pidList = xzalloc(sizeof(*pidList)); while ((p = procps_scan(p, PSSCAN_PID|PSSCAN_COMM|PSSCAN_ARGVN/*|PSSCAN_EXE*/))) { if (comm_match(p, procName) /* or we require argv0 to match (essential for matching reexeced /proc/self/exe)*/ || (p->argv0 && strcmp(bb_basename(p->argv0), procName) == 0) /* or we require /proc/PID/exe link to match */ /* || (p->exe && strcmp(bb_basename(p->exe), procName) == 0)*/ ) { pidList = xrealloc_vector(pidList, 2, i); pidList[i++] = p->pid; } } pidList[i] = 0; return pidList; }
extern int ps_main(int argc, char **argv) { procps_status_t * p; int i, len; #ifdef CONFIG_FEATURE_AUTOWIDTH struct winsize win = { 0, 0, 0, 0 }; int terminal_width = TERMINAL_WIDTH; #else #define terminal_width TERMINAL_WIDTH #endif #ifdef CONFIG_SELINUX int use_selinux = 0; security_id_t sid; if(is_flask_enabled() && argv[1] && !strcmp(argv[1], "-c") ) use_selinux = 1; #endif #ifdef CONFIG_FEATURE_AUTOWIDTH ioctl(fileno(stdout), TIOCGWINSZ, &win); if (win.ws_col > 0) terminal_width = win.ws_col - 1; #endif #ifdef CONFIG_SELINUX if(use_selinux) printf(" PID Context Stat Command\n"); else #endif printf(" PID Uid VmSize Stat Command\n"); #ifdef CONFIG_SELINUX while ((p = procps_scan(1, use_selinux, &sid)) != 0) { #else while ((p = procps_scan(1)) != 0) { #endif char *namecmd = p->cmd; #ifdef CONFIG_SELINUX if(use_selinux) { char sbuf[128]; len = sizeof(sbuf); if(security_sid_to_context(sid, (security_context_t)&sbuf, &len)) strcpy(sbuf, "unknown"); len = printf("%5d %-32s %s ", p->pid, sbuf, p->state); } else #endif if(p->rss == 0) len = printf("%5d %-8s %s ", p->pid, p->user, p->state); else len = printf("%5d %-8s %6ld %s ", p->pid, p->user, p->rss, p->state); i = terminal_width-len; if(namecmd != 0 && namecmd[0] != 0) { if(i < 0) i = 0; if(strlen(namecmd) > i) namecmd[i] = 0; printf("%s\n", namecmd); } else { namecmd = p->short_cmd; if(i < 2) i = 2; if(strlen(namecmd) > (i-2)) namecmd[i-2] = 0; printf("[%s]\n", namecmd); } free(p->cmd); } return EXIT_SUCCESS; }
int pgrep_main(int argc UNUSED_PARAM, char **argv) { unsigned pid = getpid(); int signo = SIGTERM; unsigned opt; int scan_mask = PSSCAN_COMM; char *first_arg; int first_arg_idx; int matched_pid; char *cmd_last; procps_status_t *proc; /* These are initialized to 0 */ struct { regex_t re_buffer; regmatch_t re_match[1]; } Z; #define re_buffer (Z.re_buffer) #define re_match (Z.re_match ) memset(&Z, 0, sizeof(Z)); /* We must avoid interpreting -NUM (signal num) as an option */ first_arg_idx = 1; while (1) { first_arg = argv[first_arg_idx]; if (!first_arg) break; /* not "-<small_letter>..."? */ if (first_arg[0] != '-' || first_arg[1] < 'a' || first_arg[1] > 'z') { argv[first_arg_idx] = NULL; /* terminate argv here */ break; } first_arg_idx++; } opt = getopt32(argv, "vlfxon"); argv[first_arg_idx] = first_arg; argv += optind; //argc -= optind; - unused anyway if (OPT_FULL) scan_mask |= PSSCAN_ARGVN; if (pkill) { if (OPT_LIST) { /* -l: print the whole signal list */ print_signames(); return 0; } if (first_arg && first_arg[0] == '-') { signo = get_signum(&first_arg[1]); if (signo < 0) /* || signo > MAX_SIGNUM ? */ bb_error_msg_and_die("bad signal name '%s'", &first_arg[1]); argv++; } } /* One pattern is required */ if (!argv[0] || argv[1]) bb_show_usage(); xregcomp(&re_buffer, argv[0], 0); matched_pid = 0; cmd_last = NULL; proc = NULL; while ((proc = procps_scan(proc, scan_mask)) != NULL) { char *cmd; if (proc->pid == pid) continue; cmd = proc->argv0; if (!cmd) { cmd = proc->comm; } else { int i = proc->argv_len; while (i) { if (!cmd[i]) cmd[i] = ' '; i--; } } /* NB: OPT_INVERT is always 0 or 1 */ if ((regexec(&re_buffer, cmd, 1, re_match, 0) == 0 /* match found */ && (!OPT_ANCHOR || (re_match[0].rm_so == 0 && re_match[0].rm_eo == (regoff_t)strlen(cmd)))) ^ OPT_INVERT ) { matched_pid = proc->pid; if (OPT_LAST) { free(cmd_last); cmd_last = xstrdup(cmd); continue; } act(proc->pid, cmd, signo, opt); if (OPT_FIRST) break; } } if (cmd_last) { act(matched_pid, cmd_last, signo, opt); if (ENABLE_FEATURE_CLEAN_UP) free(cmd_last); } return matched_pid == 0; /* return 1 if no processes listed/signaled */ }
int pgrep_main(int argc UNUSED_PARAM, char **argv) { unsigned pid; int signo; unsigned opt; int scan_mask; int matched_pid; int sid2match, ppid2match; char *cmd_last; procps_status_t *proc; /* These are initialized to 0 */ struct { regex_t re_buffer; regmatch_t re_match[1]; } Z; #define re_buffer (Z.re_buffer) #define re_match (Z.re_match ) memset(&Z, 0, sizeof(Z)); /* Parse -SIGNAL for pkill. Must be first option, if present */ signo = SIGTERM; if (pkill && argv[1] && argv[1][0] == '-') { int temp = get_signum(argv[1]+1); if (temp != -1) { signo = temp; argv++; } } /* Parse remaining options */ ppid2match = -1; sid2match = -1; opt = getopt32(argv, "vlfxons:+P:+", &sid2match, &ppid2match); argv += optind; if (pkill && OPT_LIST) { /* -l: print the whole signal list */ print_signames(); return 0; } pid = getpid(); if (sid2match == 0) sid2match = getsid(pid); scan_mask = PSSCAN_COMM | PSSCAN_ARGV0; if (OPT_FULL) scan_mask |= PSSCAN_ARGVN; /* One pattern is required, if no -s and no -P */ if ((sid2match & ppid2match) < 0 && (!argv[0] || argv[1])) bb_show_usage(); if (argv[0]) xregcomp(&re_buffer, argv[0], OPT_ANCHOR ? REG_EXTENDED : (REG_EXTENDED|REG_NOSUB)); matched_pid = 0; cmd_last = NULL; proc = NULL; while ((proc = procps_scan(proc, scan_mask)) != NULL) { char *cmd; if (proc->pid == pid) continue; cmd = proc->argv0; if (!cmd) { cmd = proc->comm; } else { int i = proc->argv_len; while (--i >= 0) { if ((unsigned char)cmd[i] < ' ') cmd[i] = ' '; } } if (ppid2match >= 0 && ppid2match != proc->ppid) continue; if (sid2match >= 0 && sid2match != proc->sid) continue; /* NB: OPT_INVERT is always 0 or 1 */ if (!argv[0] || (regexec(&re_buffer, cmd, 1, re_match, 0) == 0 /* match found */ && (!OPT_ANCHOR || (re_match[0].rm_so == 0 && re_match[0].rm_eo == (regoff_t)strlen(cmd))) ) ^ OPT_INVERT ) { matched_pid = proc->pid; if (OPT_LAST) { free(cmd_last); cmd_last = xstrdup(cmd); continue; } act(proc->pid, cmd, signo); if (OPT_FIRST) break; } } if (cmd_last) { act(matched_pid, cmd_last, signo); if (ENABLE_FEATURE_CLEAN_UP) free(cmd_last); } return matched_pid == 0; /* return 1 if no processes listed/signaled */ }
int kill_main(int argc, char **argv) { char *arg; pid_t pid; int signo = SIGTERM, errors = 0, quiet = 0; #if !ENABLE_KILLALL && !ENABLE_KILLALL5 #define killall 0 #define killall5 0 #else /* How to determine who we are? find 3rd char from the end: * kill, killall, killall5 * ^i ^a ^l - it's unique * (checking from the start is complicated by /bin/kill... case) */ const char char3 = argv[0][strlen(argv[0]) - 3]; #define killall (ENABLE_KILLALL && char3 == 'a') #define killall5 (ENABLE_KILLALL5 && char3 == 'l') #endif /* Parse any options */ argc--; arg = *++argv; if (argc < 1 || arg[0] != '-') { goto do_it_now; } /* The -l option, which prints out signal names. * Intended usage in shell: * echo "Died of SIG`kill -l $?`" * We try to mimic what kill from coreutils-6.8 does */ if (arg[1] == 'l' && arg[2] == '\0') { if (argc == 1) { /* Print the whole signal list */ print_signames(); return 0; } /* -l <sig list> */ while ((arg = *++argv)) { if (isdigit(arg[0])) { signo = bb_strtou(arg, NULL, 10); if (errno) { bb_error_msg("unknown signal '%s'", arg); return EXIT_FAILURE; } /* Exitcodes >= 0x80 are to be treated * as "killed by signal (exitcode & 0x7f)" */ puts(get_signame(signo & 0x7f)); /* TODO: 'bad' signal# - coreutils says: * kill: 127: invalid signal * we just print "127" instead */ } else { signo = get_signum(arg); if (signo < 0) { bb_error_msg("unknown signal '%s'", arg); return EXIT_FAILURE; } printf("%d\n", signo); } } /* If they specified -l, we are all done */ return EXIT_SUCCESS; } /* The -q quiet option */ if (killall && arg[1] == 'q' && arg[2] == '\0') { quiet = 1; arg = *++argv; argc--; if (argc < 1) bb_show_usage(); if (arg[0] != '-') goto do_it_now; } arg++; /* skip '-' */ /* -o PID? (if present, it always is at the end of command line) */ if (killall5 && arg[0] == 'o') goto do_it_now; if (argc > 1 && arg[0] == 's' && arg[1] == '\0') { /* -s SIG? */ argc--; arg = *++argv; } /* else it must be -SIG */ signo = get_signum(arg); if (signo < 0) { /* || signo > MAX_SIGNUM ? */ bb_error_msg("bad signal name '%s'", arg); return EXIT_FAILURE; } arg = *++argv; argc--; do_it_now: pid = getpid(); if (killall5) { pid_t sid; procps_status_t* p = NULL; int ret = 0; /* Find out our session id */ sid = getsid(pid); /* Stop all processes */ if (signo != SIGSTOP && signo != SIGCONT) kill(-1, SIGSTOP); /* Signal all processes except those in our session */ while ((p = procps_scan(p, PSSCAN_PID|PSSCAN_SID)) != NULL) { int i; if (p->sid == (unsigned)sid || p->pid == (unsigned)pid || p->pid == 1 ) { continue; } /* All remaining args must be -o PID options. * Check p->pid against them. */ for (i = 0; i < argc; i++) { pid_t omit; arg = argv[i]; if (arg[0] != '-' || arg[1] != 'o') { bb_error_msg("bad option '%s'", arg); ret = 1; goto resume; } arg += 2; if (!arg[0] && argv[++i]) arg = argv[i]; omit = bb_strtoi(arg, NULL, 10); if (errno) { bb_error_msg("invalid number '%s'", arg); ret = 1; goto resume; } if (p->pid == omit) goto dont_kill; } kill(p->pid, signo); dont_kill: ; } resume: /* And let them continue */ if (signo != SIGSTOP && signo != SIGCONT) kill(-1, SIGCONT); return ret; } /* Pid or name is required for kill/killall */ if (argc < 1) { bb_error_msg("you need to specify whom to kill"); return EXIT_FAILURE; } if (killall) { /* Looks like they want to do a killall. Do that */ while (arg) { pid_t* pidList; pidList = find_pid_by_name(arg); if (*pidList == 0) { errors++; if (!quiet) bb_error_msg("%s: no process killed", arg); } else { pid_t *pl; for (pl = pidList; *pl; pl++) { if (*pl == pid) continue; if (kill(*pl, signo) == 0) continue; errors++; if (!quiet) bb_perror_msg("can't kill pid %d", (int)*pl); } } free(pidList); arg = *++argv; } return errors; } /* Looks like they want to do a kill. Do that */ while (arg) { #if ENABLE_ASH || ENABLE_HUSH /* * We need to support shell's "hack formats" of * " -PRGP_ID" (yes, with a leading space) * and " PID1 PID2 PID3" (with degenerate case "") */ while (*arg != '\0') { char *end; if (*arg == ' ') arg++; pid = bb_strtoi(arg, &end, 10); if (errno && (errno != EINVAL || *end != ' ')) { bb_error_msg("invalid number '%s'", arg); errors++; break; } if (kill(pid, signo) != 0) { bb_perror_msg("can't kill pid %d", (int)pid); errors++; } arg = end; /* can only point to ' ' or '\0' now */ } #else pid = bb_strtoi(arg, NULL, 10); if (errno) { bb_error_msg("invalid number '%s'", arg); errors++; } else if (kill(pid, signo) != 0) { bb_perror_msg("can't kill pid %d", (int)pid); errors++; } #endif arg = *++argv; } return errors; }
int kill_main(int argc, char **argv) { char *arg; pid_t pid; int signo = SIGTERM, errors = 0, quiet = 0; #if !ENABLE_KILLALL && !ENABLE_KILLALL5 #define killall 0 #define killall5 0 #else /* How to determine who we are? find 3rd char from the end: * kill, killall, killall5 * ^i ^a ^l - it's unique * (checking from the start is complicated by /bin/kill... case) */ const char char3 = argv[0][strlen(argv[0]) - 3]; #define killall (ENABLE_KILLALL && char3 == 'a') #define killall5 (ENABLE_KILLALL5 && char3 == 'l') #endif /* Parse any options */ argc--; arg = *++argv; if (argc < 1 || arg[0] != '-') { goto do_it_now; } /* The -l option, which prints out signal names. * Intended usage in shell: * echo "Died of SIG`kill -l $?`" * We try to mimic what kill from coreutils-6.8 does */ if (arg[1] == 'l' && arg[2] == '\0') { if (argc == 1) { /* Print the whole signal list */ print_signames(); return 0; } /* -l <sig list> */ while ((arg = *++argv)) { if (isdigit(arg[0])) { signo = bb_strtou(arg, NULL, 10); if (errno) { bb_error_msg("unknown signal '%s'", arg); return EXIT_FAILURE; } /* Exitcodes >= 0x80 are to be treated * as "killed by signal (exitcode & 0x7f)" */ puts(get_signame(signo & 0x7f)); /* TODO: 'bad' signal# - coreutils says: * kill: 127: invalid signal * we just print "127" instead */ } else { signo = get_signum(arg); if (signo < 0) { bb_error_msg("unknown signal '%s'", arg); return EXIT_FAILURE; } printf("%d\n", signo); } } /* If they specified -l, we are all done */ return EXIT_SUCCESS; } /* The -q quiet option */ if (killall && arg[1] == 'q' && arg[2] == '\0') { quiet = 1; arg = *++argv; argc--; if (argc < 1) bb_show_usage(); if (arg[0] != '-') goto do_it_now; } /* -SIG */ signo = get_signum(&arg[1]); if (signo < 0) { /* || signo > MAX_SIGNUM ? */ bb_error_msg("bad signal name '%s'", &arg[1]); return EXIT_FAILURE; } arg = *++argv; argc--; do_it_now: pid = getpid(); if (killall5) { pid_t sid; procps_status_t* p = NULL; /* Find out our own session id */ sid = getsid(pid); /* Now stop all processes */ kill(-1, SIGSTOP); /* Now kill all processes except our session */ while ((p = procps_scan(p, PSSCAN_PID|PSSCAN_SID))) { if (p->sid != (unsigned)sid && p->pid != (unsigned)pid && p->pid != 1) kill(p->pid, signo); } /* And let them continue */ kill(-1, SIGCONT); return 0; } /* Pid or name is required for kill/killall */ if (argc < 1) { bb_error_msg("you need to specify whom to kill"); return EXIT_FAILURE; } if (killall) { /* Looks like they want to do a killall. Do that */ while (arg) { pid_t* pidList; pidList = find_pid_by_name(arg); if (*pidList == 0) { errors++; if (!quiet) bb_error_msg("%s: no process killed", arg); } else { pid_t *pl; for (pl = pidList; *pl; pl++) { if (*pl == pid) continue; if (kill(*pl, signo) == 0) continue; errors++; if (!quiet) bb_perror_msg("cannot kill pid %u", (unsigned)*pl); } } free(pidList); arg = *++argv; } return errors; } /* Looks like they want to do a kill. Do that */ while (arg) { /* Support shell 'space' trick */ if (arg[0] == ' ') arg++; pid = bb_strtoi(arg, NULL, 10); if (errno) { bb_error_msg("bad pid '%s'", arg); errors++; } else if (kill(pid, signo) != 0) { bb_perror_msg("cannot kill pid %d", (int)pid); errors++; } arg = *++argv; } return errors; }