source: trunk/icedtea-web/tests/softkiller/softkiller.c@ 433

/* X Window app killer
 *
 * Author: Pavel Tisnovsky <ptisnovs@redhat.com>
 *
 * Compile:
 *     gcc -Wall -pedantic -std=c99 -o softkiller softkiller.c -lX11
 *     (please note that -std=c99 is needed because we use snprintf
 *      function which does not exist in C89/ANSI C)
 *
 * Run:
 *     ./softkiller PID
 */



#include <stdio.h>
#include <stdlib.h>
#include <glob.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <X11/Xlib.h>
#include <X11/Xatom.h>

/*
 * Number of long decimal digits + 1 (for ASCIIZ storage)
 */
#define MAX_LONG_DECIMAL_DIGITS 21

/*
 * Max line length in /proc/stat files
 */
#define MAX_LINE 8192

/*
 * Max filename length for /proc/... files
 */
#define MAX_FILENAME 32

/*
 * Return values
 */
#define EXIT_CODE_OK 0
#define EXIT_CODE_ERROR 1

/*
 * Different softkilling strategies
 */
#define TRY_TO_CLOSE_WINDOW 1
#define TRY_TO_KILL_WINDOW 1

/*
 * Delay between application of different softkilling strategies.
 */
#define SLEEP_AMOUNT 2

/*
 * Not in c89/c99...
 */
#define file_no(FP) ((FP)->_fileno)

/*
 * Basic information about given process
 */
typedef struct ProcStruct
{
    long uid, pid, ppid;
    char cmd[MAX_LINE];
} ProcStruct;

ProcStruct *P = NULL;

int N = 0;

Display *display;
Window root_window;
Atom atom_pid;



/*
 * Read basic process info from the file /proc/${PID}/stat
 * where ${PID} is process ID.
 */
int read_process_info(char *file_name_part, ProcStruct *P)
{
    FILE *fin;
    char filename[MAX_FILENAME];
    struct stat stat;

    /* try to open file /proc/${PID}/stat for reading */
    snprintf(filename, sizeof(filename), "%s%s", file_name_part, "/stat");
    fin = fopen(filename, "r");

    if (fin == NULL)
    {
        return 0; /* process vanished since glob() */
    }

    /* read basic process info */
    if (3 != fscanf(fin, "%ld %s %*c %ld", &(P->pid), P->cmd, &(P->ppid)))
    {
        fclose(fin);
        return 0; /* Problem with file format, AFAIK should not happen */
    }
    if (fstat(file_no(fin), &stat))
    {
        fclose(fin);
        return 0;
    }
    P->uid = stat.st_uid;

    /* fin can't be NULL here */
    fclose(fin);
    return 1;
}



/*
 * Read command line parameters for given ${PID}
 */
int read_cmd_line(char *file_name_part, char *cmd)
{
    FILE *fin;
    char filename[MAX_FILENAME];
    int c;
    int k = 0;

    /* try to open file /proc/${PID}/cmdline for reading */
    snprintf(filename, sizeof(filename), "%s%s", file_name_part, "/cmdline");
    fin = fopen(filename, "r");

    if (fin == NULL)
    {
        return 0; /* process vanished since glob() */
    }

    /* replace \0 by spaces */
    while (k < MAX_LINE - 1 && EOF != (c = fgetc(fin)))
    {
        cmd[k++] = c == '\0' ? ' ' : c;
    }
    if (k > 0)
    {
        cmd[k] = '\0';
    }

    /* fin can't be NULL here */
    fclose(fin);
    return 1;
}



/*
 * Fill in an array pointed by P.
 */
int get_processes(void)
{
    glob_t globbuf;
    unsigned int i, j;

    glob("/proc/[0-9]*", GLOB_NOSORT, NULL, &globbuf);

    P = calloc(globbuf.gl_pathc, sizeof(struct ProcStruct));
    if (P == NULL)
    {
        fprintf(stderr, "Problems with malloc, it should not happen...\n");
        exit(1);
    }

    for (i = j = 0; i < globbuf.gl_pathc; i++)
    {
        char * name_part = globbuf.gl_pathv[globbuf.gl_pathc - i - 1];
        if (read_process_info(name_part, &(P[j])) == 0)
        {
            continue;
        }
        if (read_cmd_line(name_part, P[j].cmd) == 0)
        {
            continue;
        }
        /* Debug output */
        /* printf("uid=%5ld, pid=%5ld, ppid=%5ld, cmd='%s'\n", P[j].uid, P[j].pid, P[j].ppid, P[j].cmd); */
        j++;
    }
    globfree(&globbuf);
    return j;
}



/*
 * Try to open X Display
 */
Display * open_display(void)
{
    Display *display = XOpenDisplay(0);
    if (display == NULL)
    {
        puts("Cannot open display");
        exit(EXIT_CODE_ERROR);
    }
    return display;
}



/*
 * Return the atom identifier for the atom name "_NET_WM_PID"
 */
Atom get_atom_pid(Display *display)
{
    Atom atom_pid = XInternAtom(display, "_NET_WM_PID", True);
    if (atom_pid == None)
    {
        printf("No such atom _NET_WM_PID");
        exit(EXIT_CODE_ERROR);
    }
    return atom_pid;
}



/*
 * Try to focus the window and send Ctrl+W to it.
 */
void close_window(Window window, long processId)
{
    char windowIDstr[MAX_LONG_DECIMAL_DIGITS];
    pid_t pid;

    snprintf(windowIDstr, MAX_LONG_DECIMAL_DIGITS, "%ld", window);
    char *args[] =
    {
        "/usr/bin/xdotool",
        "windowfocus",
        windowIDstr,
        "windowactivate",
        windowIDstr,
        "key",
        "--window",
        windowIDstr,
        "--clearmodifiers",
        "Ctrl+W",
        (char *) NULL
    };
    if ((pid = fork()) == -1)
    {
        perror("some fork error");
    }
    else if (pid == 0)
    {
        /* child process */
        printf("Trying to close window ID %ld for process ID %ld\n", (long)window, processId);
        execv("/usr/bin/xdotool", args);
    }
    else
    {
        /* parent process */
        sleep(SLEEP_AMOUNT);
    }
}



/*
 * Run xkill to kill window with specified window ID
 */
void kill_window(Window window, long processId)
{
    char windowIDstr[MAX_LONG_DECIMAL_DIGITS];
    pid_t pid;

    /* we need to convert window id (long) into a string to call xkill */
    snprintf(windowIDstr, MAX_LONG_DECIMAL_DIGITS, "%ld", window);
    char *args[] =
    {
        "/usr/bin/xkill",
        "-id",
        windowIDstr,
        (char *) NULL
    };
    if ((pid = fork()) == -1)
    {
        perror("some fork error");
    }
    else if (pid == 0)
    {
        printf("Trying to kill window ID %ld for process ID %ld\n", (long)window, processId);
        execv("/usr/bin/xkill", args);
    }
    else
    {
        // parent
        sleep(SLEEP_AMOUNT);
    }
}



/*
 * Recursivelly search for a window(s) associated with given process ID
 */
void search_and_destroy(Display *display, Window window, Atom atomPID, long processId)
{
    Atom           type;
    int            format;
    unsigned long  nItems;
    unsigned long  bytesAfter;
    unsigned char *propertyPID = NULL;

    /* read _NET_WM_PID property, if exists */
    if (Success == XGetWindowProperty(display, window, atomPID, 0, 1, False, XA_CARDINAL,
                                         &type, &format, &nItems, &bytesAfter, &propertyPID))
    {
        if (propertyPID != NULL)
        {
            if (processId == *((unsigned long *)propertyPID))
            {
                printf("Found window ID %ld for process ID %ld\n", (long)window, processId);
                XFree(propertyPID);
#if TRY_TO_CLOSE_WINDOW == 1
                close_window(window, processId);
#endif
#if TRY_TO_KILL_WINDOW == 1
                kill_window(window, processId);
#endif
            }
        }
    }

    /* recurse into child windows */
    Window    rootWindow;
    Window    parentWindow;
    Window   *childWindows;
    unsigned  nChildren;
    if (0 != XQueryTree(display, window, &rootWindow, &parentWindow, &childWindows, &nChildren))
    {
        unsigned int i;
        for(i = 0; i < nChildren; i++)
        {
            search_and_destroy(display, childWindows[i], atomPID, processId);
        }
    }
}



/*
 * Kill process with given ancestor PID.
 */
void kill_process(int pid)
{
    Atom atom_pid = get_atom_pid(display);
    printf("Searching for windows associated with PID %d\n", pid);
    search_and_destroy(display, root_window, atom_pid, pid);
}



/*
 * Kill all processes with given ppid (ancestor PID)
 */
void kill_processes_with_ppid(int ppid)
{
    int i;
    int done = 1;
    for (i = 0; i < N; i++)
    {
        if (ppid == P[i].ppid)
        {
            int pid = P[i].pid;
            printf("uid=%5ld, pid=%5ld, ppid=%5ld, cmd='%s'\n", P[i].uid, P[i].pid, P[i].ppid, P[i].cmd);
            kill_processes_with_ppid(pid);
            /* at least one child process exists */
            done = 0;
            kill_process(pid);
        }
    }
    kill_process(ppid);
    /* if none child processes have been found we are at bottom of the process tree */
    if (done)
    {
        return;
    }
}



/* TODO: better check for user input */
int read_pid(int argc, char **argv)
{
    int pid;

    if (argc != 2)
    {
        puts("Usage softkiller PID");
        exit(EXIT_CODE_ERROR);
    }

    pid = atoi(argv[1]);

    if (sscanf(argv[1], "%d", &pid) != 1)
    {
        printf("Wrong PID entered: %s\n", argv[1]);
        exit(EXIT_CODE_ERROR);
    }

    /* basic check (nobody should try to kill PID 0 :) */
    if (pid <= 0)
    {
        printf("Wrong process ID %d\n", pid);
        exit(EXIT_CODE_ERROR);
    }

    return pid;
}



/*
 * Entry point to this tool.
 */
int main(int argc, char **argv)
{
    int pid = read_pid(argc, argv);

    printf("ancestor PID to kill: %d\n", pid);

    N = get_processes();
    printf("N = %d\n", N);
    display = open_display();
    root_window = XDefaultRootWindow(display);
    atom_pid = get_atom_pid(display);

    kill_processes_with_ppid(pid);

    puts("*** Done! ***");
    return 0;
}