source: neercs/trunk/src/grab.c @ 2505 Tweet

/*
 *  neercs        console-based window manager
 *  Copyright (c) 2008 Pascal Terjan
 *                All Rights Reserved
 *
 *  $Id$
 *
 *  This program is free software. It comes without any warranty, to
 *  the extent permitted by applicable law. You can redistribute it
 *  and/or modify it under the terms of the Do What The Fuck You Want
 *  To Public License, Version 2, as published by Sam Hocevar. See
 *  http://sam.zoy.org/wtfpl/COPYING for more details.
 */

#include "config.h"

#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#if defined USE_GRAB
#   include <sys/ioctl.h>
#   include <sys/ptrace.h>
#   include <sys/stat.h>
#   include <sys/syscall.h>
#   include <sys/user.h>
#   include <sys/wait.h>

#   include <linux/kdev_t.h>
#   include <linux/major.h>
#endif

#include "neercs.h"

#define X(x) #x
#define STRINGIFY(x) X(x)

#if defined __x86_64__
#   define RAX rax
#   define RBX rbx
#   define RCX rcx
#   define RDX rdx
#   define RSP rsp
#   define RIP rip
#   define RDI rdi
#   define RSI rsi
#   define SYSCALL 0x050fL /* 0F 05 = syscall */
#   define FMT "%016lx"
#else
#   define RAX eax
#   define RBX ebx
#   define RCX ecx
#   define RDX edx
#   define RSP esp
#   define RIP eip
#   define RDI edi
#   define RSI esi
#   define SYSCALL 0x80cd /* CD 80 = int $0x80 */
#   define FMT "%08lx"
#endif

#if defined USE_GRAB
/* For debugging purposes only. Prints register and stack information. */
static void print_registers(pid_t pid)
{
    union { long int l; unsigned char data[sizeof(long int)]; } inst;
    struct user_regs_struct regs;
    int i;

    if(ptrace(PTRACE_GETREGS, pid, NULL, &regs) < 0)
    {
        perror("ptrace_getregs");
        exit(errno);
    }

    fprintf(stderr, "  / %s: "FMT"   ", STRINGIFY(RAX), regs.RAX);
    fprintf(stderr, "%s: "FMT"\n", STRINGIFY(RBX), regs.RBX);
    fprintf(stderr, "  | %s: "FMT"   ", STRINGIFY(RCX), regs.RCX);
    fprintf(stderr, "%s: "FMT"\n", STRINGIFY(RDX), regs.RDX);
    fprintf(stderr, "  | %s: "FMT"   ", STRINGIFY(RDI), regs.RDI);
    fprintf(stderr, "%s: "FMT"\n", STRINGIFY(RSI), regs.RSI);
    fprintf(stderr, "  | %s: "FMT"   ", STRINGIFY(RSP), regs.RSP);
    fprintf(stderr, "%s: "FMT"\n", STRINGIFY(RIP), regs.RIP);

    inst.l = ptrace(PTRACE_PEEKTEXT, pid, regs.RIP - 4, 0);
    fprintf(stderr, "  \\ code: ... %02x %02x %02x %02x <---> ",
            inst.data[0], inst.data[1], inst.data[2], inst.data[3]);
    inst.l = ptrace(PTRACE_PEEKTEXT, pid, regs.RIP, 0);
    fprintf(stderr, "%02x %02x %02x %02x ...\n",
            inst.data[0], inst.data[1], inst.data[2], inst.data[3]);

    fprintf(stderr, "  \\ stack: ... ");
    for(i = -16; i < 24; i += sizeof(long))
    {
        inst.l = ptrace(PTRACE_PEEKDATA, pid, regs.RSP + i, 0);
#if defined __x86_64__
        fprintf(stderr, "%02x %02x %02x %02x %02x %02x %02x %02x ",
                inst.data[0], inst.data[1], inst.data[2], inst.data[3],
                inst.data[4], inst.data[5], inst.data[6], inst.data[7]);
#else
        fprintf(stderr, "%02x %02x %02x %02x ",
                inst.data[0], inst.data[1], inst.data[2], inst.data[3]);
#endif
        if(i == 0)
            fprintf(stderr, "[%s] ", STRINGIFY(RSP));
    }
    fprintf(stderr, "...\n");
}

/* FIXME: this function and the following have alignment issues */
static int memcpy_from_target(pid_t pid, void* dest, long src, size_t n)
{
    long *d = (long*)dest;
    unsigned int i;

    for(i = 0; i < n / sizeof(long); i++)
    {
        d[i] = ptrace(PTRACE_PEEKTEXT, pid, src + i * sizeof(long), 0);
        if(errno)
        {
            perror("ptrace_peektext");
            return -1;
        }
    }
    return 0;
}

static int memcpy_into_target(pid_t pid, long dest, void* src, size_t n)
{
    long *s = (long*) src;
    unsigned int i;

    for(i = 0; i < n / sizeof(long); i++)
    {
        if(ptrace(PTRACE_POKETEXT, pid, dest + i * sizeof(long), s[i]) == -1)
        {
            perror("ptrace_poketext");
            return -1;
        }
    }
    return 0;
}

static long do_syscall(pid_t pid, long call, long arg1, long arg2, long arg3)
{
    /* Method for remote syscall:
     *  - wait until the traced application exits from a syscall
     *  - save registers
     *  - rewind eip/rip to point on the syscall instruction
     *  - single step: execute syscall instruction
     *  - restore registers */
    struct user_regs_struct regs, oldregs;
    long oinst;

    for(;;)
    {
        if(ptrace(PTRACE_GETREGS, pid, NULL, &oldregs) < 0)
        {
            fprintf(stderr, "PTRACE_GETREGS failed\n");
            return -1;
        }

        oinst = ptrace(PTRACE_PEEKTEXT, pid, oldregs.RIP - 2, 0) & 0xffff;

        if(oinst == SYSCALL)
            break;

        if(ptrace(PTRACE_SYSCALL, pid, NULL, 0) < 0)
        {
            perror("ptrace_syscall (1)");
            return -1;
        }
        waitpid(pid, NULL, 0);

        if(ptrace(PTRACE_SYSCALL, pid, NULL, 0) < 0)
        {
            perror("ptrace_syscall (2)");
            return -1;
        }
        waitpid(pid, NULL, 0);
    }

    regs = oldregs;
    regs.RIP = regs.RIP - 2;
    regs.RAX = call;
#if defined __x86_64__
    regs.RDI = arg1;
    regs.RSI = arg2;
    regs.RDX = arg3;
#else
    regs.RBX = arg1;
    regs.RCX = arg2;
    regs.RDX = arg3;
#endif

    if(ptrace(PTRACE_SETREGS, pid, NULL, &regs) < 0)
    {
        fprintf(stderr, "PTRACE_SETREGS failed\n");
        return -1;
    }

    if(ptrace(PTRACE_SINGLESTEP, pid, NULL, NULL) < 0)
    {
        fprintf(stderr, "PTRACE_SINGLESTEP failed\n");
        return -1;
    }
    waitpid(pid, NULL, 0);

    if(ptrace(PTRACE_GETREGS, pid, NULL, &regs) < 0)
    {
        fprintf(stderr, "PTRACE_GETREGS failed\n");
        return -1;
    }

    if(ptrace(PTRACE_SETREGS, pid, NULL, &oldregs) < 0)
    {
        fprintf(stderr, "PTRACE_SETREGS failed\n");
        return -1;
    }

    debug("syscall %ld returned %ld", call, regs.RAX);

    if((long)regs.RAX < 0)
    {
        errno = -(long)regs.RAX;
        perror("syscall");
        return -1;
    }

    return regs.RAX;
}

static int do_close(pid_t pid, int fd)
{
    return do_syscall(pid, SYS_close, fd, 0, 0);
}

static int do_dup2(pid_t pid, int oldfd, int newfd)
{
    return do_syscall(pid, SYS_dup2, oldfd, newfd, 0);
}

static int do_open(pid_t pid, char *path, int mode)
{
    char path_data[4096], backup_data[4096];
    struct user_regs_struct regs;
    long target_data;
    size_t size = (strlen(path) + sizeof(long)) & ~(sizeof(long) - 1L);
    int ret;

    if(ptrace(PTRACE_GETREGS, pid, NULL, &regs) < 0)
    {
        fprintf(stderr, "PTRACE_GETREGS failed\n");
        return errno;
    }

    target_data = (regs.RSP - size) & ~(sizeof(long) - 1L);

    /* Backup the data that we will use */
    if(memcpy_from_target(pid, backup_data, target_data, size) < 0)
        return -1;

    /* +4 (or 8) because it's truncated on a multiple of 4 (or 8)
     * and we need 1 */
    sprintf(path_data, "%s", path);
    memcpy_into_target(pid, target_data, path_data, size);

    ret = do_syscall(pid, SYS_open, target_data, O_RDWR, 0755);

    /* Restore the datas */
    memcpy_into_target(pid, target_data, backup_data, size);

    if(ret < 0)
    {
        errno = ret;
        return -1;
    }

    return ret;
}

static int do_setsid(pid_t pid)
{
    long ret;

    debug("Running setsid on process %d (sid=%d)", pid, getsid(pid));

    ret = do_syscall(pid, SYS_setpgid, 0, getsid(pid), 0);
    if(ret < 0)
    {
        fprintf(stderr, "syscall setpgid failed\n");
        return ret;
    }

    if(ret != 0)
    {
        fprintf(stderr, "setpgid returned %ld\n", ret);
        return -ret;
    }

    ret = do_syscall(pid, SYS_setsid, 0, 0, 0);
    if(ret < 0)
    {
        fprintf(stderr, "syscall setsid failed\n");
        return ret;
    }

    debug("pid %d has now sid %d", pid, getsid(pid));

    return 0;
}
#endif

int grab_process(long pid, char *ptyname, int ptyfd)
{
#if defined USE_GRAB
    int i, fd = 0, mode, ret;
    char fdstr[1024];
    char to_open[3];
    struct stat stat_buf;

    debug("pty is %s", ptyname);

    if(ptrace(PTRACE_ATTACH, pid, 0, 0) < 0)
    {
        fprintf(stderr, "Cannot access process %ld\n", pid);
        return errno;
    }
    waitpid(pid, NULL, 0);

    for(i = 0; i <= 2; i++)
    {
        snprintf(fdstr, sizeof(fdstr), "/proc/%ld/fd/%d", pid, i);
        to_open[i] = 0;
        lstat(fdstr, &stat_buf);
        if((stat_buf.st_mode & S_IRUSR) && (stat_buf.st_mode & S_IWUSR))
            mode = O_RDWR;
        else if(stat_buf.st_mode & S_IWUSR)
            mode = O_WRONLY;
        else
            mode = O_RDONLY;

        if(stat(fdstr, &stat_buf) < 0)
            continue;

        if(!S_ISCHR(stat_buf.st_mode)
            || MAJOR(stat_buf.st_rdev) != UNIX98_PTY_SLAVE_MAJOR)
            continue;

        debug("found pty %d", i);

        if((ret = do_close(pid, i)))
        {
            fprintf(stderr, "do_close %s\n", strerror(ret));
        }
        to_open[i] = 1;
    }

    if((ret = do_setsid(pid)))
    {
        fprintf(stderr, "do_setsid %s\n", strerror(ret));
    }

    for(i = 0; i <= 2; i++)
    {
        if(!to_open[i])
            continue;
        fd = do_open(pid, ptyname, mode);
        if(fd < 0)
        {
            perror("do_open");
        }
        ret = do_dup2(pid, fd, i);
        if(ret < 0)
        {
            perror("do_dup2");
        }
    }

    kill(pid, SIGWINCH);
    ptrace(PTRACE_DETACH, pid, 0, 0);

    return 0;
#else
    return -1;
#endif
}