procps/skill.c

/*
 * Copyright 1998-2002 by Albert Cahalan; all rights resered.
 * This file may be used subject to the terms and conditions of the
 * GNU Library General Public License Version 2, or any later version
 * at your option, as published by the Free Software Foundation.
 * This program 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 Library General Public License for more details.
 */
#include <fcntl.h>
#include <pwd.h>
#include <dirent.h>
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include "proc/pwcache.h"
#include "proc/sig.h"
#include "proc/devname.h"
#include "proc/procps.h"  /* char *user_from_uid(uid_t uid) */
#include "proc/version.h" /* procps_version */

static int f_flag, i_flag, v_flag, w_flag, n_flag;

static int tty_count, uid_count, cmd_count, pid_count;
static int *ttys;
static uid_t *uids;
static const char **cmds;
static int *pids;

#define ENLIST(thing,addme) do{ \
if(!thing##s) thing##s = malloc(sizeof(*thing##s)*saved_argc); \
if(!thing##s) fprintf(stderr,"No memory.\n"),exit(2); \
thing##s[thing##_count++] = addme; \
}while(0)

static int my_pid;
static int saved_argc;

static int sig_or_pri;

static int program = -1;
#define PROG_KILL  1
#define PROG_SKILL 2
/* #define PROG_NICE  3 */ /* easy, but the old one isn't broken */
#define PROG_SNICE 4


/********************************************************************/

static void display_kill_version(void){
  switch(program) {
    case PROG_KILL:
      fprintf(stdout, "kill (%s)\n",procps_version);
      return;
    case PROG_SKILL:
      fprintf(stdout, "skill (%s)\n",procps_version);
      return;
    case PROG_SNICE:
      fprintf(stdout, "snice (%s)\n",procps_version);
      return;
    default:
      fprintf(stdout, "unknown (%s)\n",procps_version);
      return;
  }
}

/***** kill or nice a process */
static void hurt_proc(int tty, int uid, int pid, const char *restrict const cmd){
  int failed;
  int saved_errno;
  char dn_buf[1000];
  dev_to_tty(dn_buf, 999, tty, pid, ABBREV_DEV);
  if(i_flag){
    char buf[8];
    fprintf(stderr, "%-8s %-8s %5d %-16.16s   ? ",
      (char*)dn_buf,user_from_uid(uid),pid,cmd
    );
    if(!fgets(buf,7,stdin)){
      printf("\n");
      exit(0);
    }
    if(*buf!='y' && *buf!='Y') return;
  }
  /* do the actual work */
  if(program==PROG_SKILL) failed=kill(pid,sig_or_pri);
  else                    failed=setpriority(PRIO_PROCESS,pid,sig_or_pri);
  saved_errno = errno;
  if(w_flag && failed){
    fprintf(stderr, "%-8s %-8s %5d %-16.16s   ",
      (char*)dn_buf,user_from_uid(uid),pid,cmd
    );
    errno = saved_errno;
    perror("");
    return;
  }
  if(i_flag) return;
  if(v_flag){
    printf("%-8s %-8s %5d %-16.16s\n",
      (char*)dn_buf,user_from_uid(uid),pid,cmd
    );
    return;
  }
  if(n_flag){
   printf("%d\n",pid);
   return;
  }
}


/***** check one process */
static void check_proc(int pid){
  char buf[128];
  struct stat statbuf;
  char *tmp;
  int tty;
  int fd;
  int i;
  if(pid==my_pid) return;
  sprintf(buf, "/proc/%d/stat", pid); /* pid (cmd) state ppid pgrp session tty */
  fd = open(buf,O_RDONLY);
  if(fd==-1){  /* process exited maybe */
    if(pids && w_flag) printf("WARNING: process %d could not be found.\n",pid);
    return;
  }
  fstat(fd, &statbuf);
  if(uids){  /* check the EUID */
    i=uid_count;
    while(i--) if(uids[i]==statbuf.st_uid) break;
    if(i==-1) goto closure;
  }
  read(fd,buf,128);
  buf[127] = '\0';
  tmp = strrchr(buf, ')');
  *tmp++ = '\0';
  i = 5; while(i--) while(*tmp++!=' '); /* scan to find tty */
  tty = atoi(tmp);
  if(ttys){
    i=tty_count;
    while(i--) if(ttys[i]==tty) break;
    if(i==-1) goto closure;
  }
  tmp = strchr(buf, '(') + 1;
  if(cmds){
    i=cmd_count;
    /* fast comparison trick -- useful? */
    while(i--) if(cmds[i][0]==*tmp && !strcmp(cmds[i],tmp)) break;
    if(i==-1) goto closure;
  }
  /* This is where we kill/nice something. */
/*  fprintf(stderr, "PID %d, UID %d, TTY %d,%d, COMM %s\n",
    pid, statbuf.st_uid, tty>>8, tty&0xf, tmp
  );
*/
  hurt_proc(tty, statbuf.st_uid, pid, tmp);
closure:
  close(fd); /* kill/nice _first_ to avoid PID reuse */
}


/***** debug function */
#if 0
static void show_lists(void){
  int i;

  fprintf(stderr, "%d TTY: ", tty_count);
  if(ttys){
    i=tty_count;
    while(i--){
      fprintf(stderr, "%d,%d%c", (ttys[i]>>8)&0xff, ttys[i]&0xff, i?' ':'\n');
    }
  }else fprintf(stderr, "\n");
  
  fprintf(stderr, "%d UID: ", uid_count);
  if(uids){
    i=uid_count;
    while(i--) fprintf(stderr, "%d%c", uids[i], i?' ':'\n');
  }else fprintf(stderr, "\n");
  
  fprintf(stderr, "%d PID: ", pid_count);
  if(pids){
    i=pid_count;
    while(i--) fprintf(stderr, "%d%c", pids[i], i?' ':'\n');
  }else fprintf(stderr, "\n");
  
  fprintf(stderr, "%d CMD: ", cmd_count);
  if(cmds){
    i=cmd_count;
    while(i--) fprintf(stderr, "%s%c", cmds[i], i?' ':'\n');
  }else fprintf(stderr, "\n");
}
#endif


/***** iterate over all PIDs */
static void iterate(void){
  int pid;
  DIR *d;
  struct dirent *de;
  if(pids){
    pid = pid_count;
    while(pid--) check_proc(pids[pid]);
    return;
  }
#if 0
  /* could setuid() and kill -1 to have the kernel wipe out a user */
  if(!ttys && !cmds && !pids && !i_flag){
  }
#endif
  d = opendir("/proc");
  if(!d){
    perror("/proc");
    exit(1);
  }
  while(( de = readdir(d) )){
    if(de->d_name[0] > '9') continue;
    if(de->d_name[0] < '1') continue;
    pid = atoi(de->d_name);
    if(pid) check_proc(pid);
  }
  closedir (d);
}

/***** kill help */
static void __attribute__ ((__noreturn__)) kill_usage(void)
{
	fprintf(stderr,
		"\nUsage: %s [options] <pid> [...]\n"
		"\nOptions:\n"
		"  <pid> [...]    send SIGTERM to every <pid> listed\n"
		"  -<signal>      specify the <signal> to be sent\n"
		"  -s <signal>    specify the <signal> to be sent\n"
		"  -l             list all signal names\n"
		"  -L             list all signal names in a nice table\n"
		"  -l <signal>    convert between signal numbers and names\n"
		"\nFor more information see kill(1).\n",
		program_invocation_short_name);
	exit(1);
}

/***** kill */
static void kill_main(int argc, const char *restrict const *restrict argv) NORETURN;
static void kill_main(int argc, const char *restrict const *restrict argv){
  const char *sigptr;
  int signo = SIGTERM;
  int exitvalue = 0;
  if(argc<2) kill_usage();
  if(!strcmp(argv[1],"-V")|| !strcmp(argv[1],"--version")){
    display_kill_version();
    exit(0);
  }
  if(argv[1][0]!='-'){
    argv++;
    argc--;
    goto no_more_args;
  }

  /* The -l option prints out signal names. */
  if(argv[1][1]=='l' && argv[1][2]=='\0'){
    if(argc==2){
      unix_print_signals();
      exit(0);
    }
    /* at this point, argc must be 3 or more */
    if(argc>128 || argv[2][0] == '-') kill_usage();
    exit(print_given_signals(argc-2, argv+2, 80));
  }

  /* The -L option prints out signal names in a nice table. */
  if(argv[1][1]=='L' && argv[1][2]=='\0'){
    if(argc==2){
      pretty_print_signals();
      exit(0);
    }
    kill_usage();
  }
  if(argv[1][1]=='-' && argv[1][2]=='\0'){
    argv+=2;
    argc-=2;
    goto no_more_args;
  }
  if(argv[1][1]=='-') kill_usage(); /* likely --help */
  // FIXME: "kill -sWINCH $$" not handled
  if(argv[1][2]=='\0' && (argv[1][1]=='s' || argv[1][1]=='n')){
    sigptr = argv[2];
    argv+=3;
    argc-=3;
  }else{
    sigptr = argv[1]+1;
    argv+=2;
    argc-=2;
  }
  signo = signal_name_to_number(sigptr);
  if(signo<0){
    fprintf(stderr, "ERROR: unknown signal name \"%s\".\n", sigptr);
    kill_usage();
  }
no_more_args:
  if(!argc) kill_usage();  /* nothing to kill? */
  while(argc--){
    long pid;
    char *endp;
    pid = strtol(argv[argc],&endp,10);
    if(!*endp && (endp != argv[argc])){
      if(!kill((pid_t)pid,signo)) continue;
      // The UNIX standard contradicts itself. If at least one process
      // is matched for each PID (as if processes could share PID!) and
      // "the specified signal was successfully processed" (the systcall
      // returned zero?) for at least one of those processes, then we must
      // exit with zero. Note that an error might have also occured.
      // The standard says we return non-zero if an error occurs. Thus if
      // killing two processes gives 0 for one and EPERM for the other,
      // we are required to return both zero and non-zero. Quantum kill???
      perror("kill");
      exitvalue = 1;
      continue;
    }
    fprintf(stderr, "ERROR: garbage process ID \"%s\".\n", argv[argc]);
    kill_usage();
  }
  exit(exitvalue);
}

/***** skill/snice help */
static void __attribute__ ((__noreturn__)) skillsnice_usage(void)
{
	if (program == PROG_SKILL) {
		fprintf(stderr,
			"\nUsage: %s [signal] [options] <expression>\n",
			program_invocation_short_name);
	} else {
		fprintf(stderr,
			"\nUsage: %s [new priority] [options] <expression>\n",
			program_invocation_short_name);
	}
	fprintf(stderr,
		"\n"
		"Options:\n"
		"  -f             fast mode (not implemented)\n"
		"  -i             interactive\n"
		"  -l             list all signal names\n"
		"  -L             list all signal names in a nice table\n"
		"  -n             no action\n"
		"  -v             explain what is being done\n"
		"  -w             enable warnings (not implemented)\n"
		"  -V, --version  display version information and exit\n"
		"\n"
		"Expression can be: terminal, user, pid, command.\n"
		"The options below may be used to ensure correct interpretation.\n"
		"  -c <command>   expression is a command name\n"
		"  -p <pid>       expression is a process id number\n"
		"  -t <tty>       expression is a terminal\n"
		"  -u <username>  expression is a username\n");
	if (program == PROG_SKILL) {
		fprintf(stderr,
			"\n"
			"The default signal is TERM. Use -l or -L to list available signals.\n"
			"Particularly useful signals include HUP, INT, KILL, STOP, CONT, and 0.\n"
			"Alternate signals may be specified in three ways: -SIGKILL -KILL -9\n"
			"\nFor more information see skill(1).\n");
	} else {
		fprintf(stderr,
			"\n"
			"The default priority is +4. (snice +4 ...)\n"
			"Priority numbers range from +20 (slowest) to -20 (fastest).\n"
			"Negative priority numbers are restricted to administrative users.\n"
			"\nFor more information see snice(1).\n");
	}
	exit(1);
}

#if 0
static void _skillsnice_usage(int line){
  fprintf(stderr,"Something at line %d.\n", line);
  skillsnice_usage();
}
#define skillsnice_usage() _skillsnice_usage(__LINE__)
#endif

#define NEXTARG (argc?( argc--, ((argptr=*++argv)) ):NULL)

/***** common skill/snice argument parsing code */
#define NO_PRI_VAL ((int)0xdeafbeef)
static void skillsnice_parse(int argc, const char *restrict const *restrict argv){
  int signo = -1;
  int prino = NO_PRI_VAL;
  int force = 0;
  int num_found = 0;
  const char *restrict argptr;
  if(argc<2) skillsnice_usage();
  if(argc==2 && argv[1][0]=='-'){
    if(!strcmp(argv[1],"-L")){
      pretty_print_signals();
      exit(0);
    }
    if(!strcmp(argv[1],"-l")){
      unix_print_signals();
      exit(0);
    }
    if(!strcmp(argv[1],"-V")|| !strcmp(argv[1],"--version")){
      display_kill_version();
      exit(0);
    }
    skillsnice_usage();
  }
  NEXTARG;
  /* Time for serious parsing. What does "skill -int 123 456" mean? */
  while(argc){
    if(force && !num_found){  /* if forced, _must_ find something */
      fprintf(stderr,"ERROR: -%c used with bad data.\n", force);
      skillsnice_usage();
    }
    force = 0;
    if(program==PROG_SKILL && signo<0 && *argptr=='-'){
      signo = signal_name_to_number(argptr+1);
      if(signo>=0){      /* found a signal */
        if(!NEXTARG) break;
        continue;
      }
    }
    if(program==PROG_SNICE && prino==NO_PRI_VAL
    && (*argptr=='+' || *argptr=='-') && argptr[1]){
      long val;
      char *endp;
      val = strtol(argptr,&endp,10);
      if(!*endp && val<=999 && val>=-999){
        prino=val;
        if(!NEXTARG) break;
        continue;
      }
    }
    /* If '-' found, collect any flags. (but lone "-" is a tty) */
    if(*argptr=='-' && argptr[1]){
      argptr++;
      do{
        switch(( force = *argptr++ )){
        default:  skillsnice_usage();
        case 't':
        case 'u':
        case 'p':
        case 'c':
          if(!*argptr){ /* nothing left here, *argptr is '\0' */
            if(!NEXTARG){
              fprintf(stderr,"ERROR: -%c with nothing after it.\n", force);
              skillsnice_usage();
            }
          }
          goto selection_collection;
        case 'f': f_flag++; break;
        case 'i': i_flag++; break;
        case 'v': v_flag++; break;
        case 'w': w_flag++; break;
        case 'n': n_flag++; break;
        case 0:
          NEXTARG;
          /*
           * If no more arguments, all the "if(argc)..." tests will fail
           * and the big loop will exit.
           */
        } /* END OF SWITCH */
      }while(force);
    } /* END OF IF */
selection_collection:
    num_found = 0; /* we should find at least one thing */
    switch(force){ /* fall through each data type */
    default: skillsnice_usage();
    case 0: /* not forced */
      if (argptr && argptr[0] == '-') /* its the next argument not a parameter */
        continue;
    case 't':
      if(argc){
        struct stat sbuf;
        char path[32];
        if(!argptr) skillsnice_usage(); /* Huh? Maybe "skill -t ''". */
        snprintf(path,32,"/dev/%s",argptr);
        if(stat(path, &sbuf)>=0 && S_ISCHR(sbuf.st_mode)){
          num_found++;
          ENLIST(tty,sbuf.st_rdev);
          if(!NEXTARG) break;
        }else if(!(argptr[1])){  /* if only 1 character */
          switch(*argptr){
          default:
            if(stat(argptr,&sbuf)<0) break; /* the shell eats '?' */
          case '-':
          case '?':
            num_found++;
            ENLIST(tty,0);
            if(!NEXTARG) break;
          }
        }
      }
      if(force) continue;
    case 'u':
      if(argc){
        struct passwd *passwd_data;
        passwd_data = getpwnam(argptr);
        if(passwd_data){
          num_found++;
          ENLIST(uid,passwd_data->pw_uid);
          if(!NEXTARG) break;
        }
      }
      if(force) continue;
    case 'p':
      if(argc && *argptr>='0' && *argptr<='9'){
        char *endp;
        int num;
        num = strtol(argptr, &endp, 0);
        if(*endp == '\0'){
          num_found++;
          ENLIST(pid,num);
          if(!NEXTARG) break;
        }
      }
      if(force) continue;
      if(num_found) continue; /* could still be an option */
    case 'c':
      if(argc){
        num_found++;
        ENLIST(cmd,argptr);
        if(!NEXTARG) break;
      }
    } /* END OF SWITCH */
  } /* END OF WHILE */
  /* No more arguments to process. Must sanity check. */
  if(!tty_count && !uid_count && !cmd_count && !pid_count){
    fprintf(stderr,"ERROR: no process selection criteria.\n");
    skillsnice_usage();
  }
  if((f_flag|i_flag|v_flag|w_flag|n_flag) & ~1){
    fprintf(stderr,"ERROR: general flags may not be repeated.\n");
    skillsnice_usage();
  }
  if(i_flag && (v_flag|f_flag|n_flag)){
    fprintf(stderr,"ERROR: -i makes no sense with -v, -f, and -n.\n");
    skillsnice_usage();
  }
  if(v_flag && (i_flag|f_flag)){
    fprintf(stderr,"ERROR: -v makes no sense with -i and -f.\n");
    skillsnice_usage();
  }
  /* OK, set up defaults */
  if(prino==NO_PRI_VAL) prino=4;
  if(signo<0) signo=SIGTERM;
  if(n_flag){
    program=PROG_SKILL;
    signo=0; /* harmless */
  }
  if(program==PROG_SKILL) sig_or_pri = signo;
  else sig_or_pri = prino;
}

/***** main body */
int main(int argc, const char *argv[]){
  const char *tmpstr;
  my_pid = getpid();
  saved_argc = argc;
  if(!argc){
    fprintf(stderr,"ERROR: could not determine own name.\n");
    exit(1);
  }
  tmpstr=strrchr(*argv,'/');
  if(tmpstr) tmpstr++;
  if(!tmpstr) tmpstr=*argv;
  if(strstr(tmpstr,"kill"))  program = PROG_KILL;
  if(strstr(tmpstr,"skill")) program = PROG_SKILL;
  if(strstr(tmpstr,"snice")) program = PROG_SNICE;
  switch(program){
  case PROG_SNICE:
  case PROG_SKILL:
    setpriority(PRIO_PROCESS,my_pid,-20);
    skillsnice_parse(argc, argv);
/*    show_lists(); */
    iterate(); /* this is it, go get them */
    break;
  case PROG_KILL:
    kill_main(argc, argv);
    break;
  default:
    fprintf(stderr,"ERROR: no \"%s\" support.\n",tmpstr);
  }
  return 0;
}