xref: /trunk/main/sal/systools/win32/kill/kill.cxx (revision cf6516809c57e1bb0a940545cca99cdad54d4ce2)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sal.hxx"

#include <tchar.h>

#ifdef _MSC_VER
#pragma warning(push,1) // disable warnings within system headers
#endif
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <tlhelp32.h>
#include <psapi.h>
#ifdef _MSC_VER
#pragma warning(pop)
#endif

#include <signal.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>

#ifndef SIGNULL
#define SIGNULL 0
#endif

#ifndef SIGKILL
#define SIGKILL 9
#endif

#include <signal.h>

#define MAX_MODULES 1024

/////////////////////////////////////////////////////////////////////////////
// Determines if a returned handle value is valid
/////////////////////////////////////////////////////////////////////////////

static inline bool IsValidHandle( HANDLE handle )
{
    return INVALID_HANDLE_VALUE != handle && NULL != handle;
}


#define elementsof( a ) (sizeof(a) / sizeof( (a)[0] ))

/////////////////////////////////////////////////////////////////////////////
// Retrieves function address in another process
/////////////////////////////////////////////////////////////////////////////

#if 1
#define GetProcAddressEx( hProcess, hModule, lpProcName ) GetProcAddress( hModule, lpProcName )
#else
FARPROC WINAPI GetProcAddressEx( HANDLE hProcess, HMODULE hModule, LPCSTR lpProcName )
{
    FARPROC lpfnProcAddress = GetProcAddress( hModule, lpProcName );

    if ( lpfnProcAddress )
    {
        DWORD   dwProcessId = GetProcessId( hProcess );

        if ( GetCurrentProcessId() != dwProcessId )
        {
            FARPROC lpfnRemoteProcAddress = NULL;
            TCHAR   szBaseName[MAX_PATH];

            if ( GetModuleBaseName( GetCurrentProcess(), hModule, szBaseName, elementsof(szBaseName) ) )
            {
                HMODULE ahModules[MAX_MODULES];
                DWORD   cbNeeded = 0;

                if ( EnumProcessModules( hProcess, ahModules, sizeof(ahModules), &cbNeeded ) )
                {
                    ULONG   nModules = cbNeeded / sizeof(ahModules[0]);

                    for ( ULONG n = 0; n < nModules; n++ )
                    {
                        TCHAR   szRemoteBaseName[MAX_PATH];

                        if ( GetModuleBaseName(
                            hProcess, ahModules[n], szRemoteBaseName, elementsof(szRemoteBaseName) ) &&
                            0 == lstrcmpi( szRemoteBaseName, szBaseName )
                            )
                        {
                            lpfnRemoteProcAddress = lpfnProcAddress;

                            if ( ahModules[n] != hModule )
                                *(LPBYTE*)&lpfnRemoteProcAddress += (LPBYTE)ahModules[n] - (LPBYTE)hModule;
                            break;
                        }
                    }
                }
            }

            lpfnProcAddress = lpfnRemoteProcAddress;
        }
    }

    return lpfnProcAddress;
}
#endif

/////////////////////////////////////////////////////////////////////////////
// Raises a signal in an other process
/////////////////////////////////////////////////////////////////////////////

static DWORD SignalToExceptionCode( int signal )
{
    switch ( signal )
    {
    case SIGSEGV:
        return EXCEPTION_ACCESS_VIOLATION;
    case SIGFPE:
        return EXCEPTION_FLT_INVALID_OPERATION;
    case SIGILL:
        return EXCEPTION_ILLEGAL_INSTRUCTION;
    case SIGINT:
        return CONTROL_C_EXIT;
    case SIGBREAK:
        return CONTROL_C_EXIT;
    default:
        return 0;
    }
}

static BOOL RaiseSignalEx( HANDLE hProcess, int sig )
{
    DWORD   dwProcessId = GetProcessId( hProcess );

    HANDLE  hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPTHREAD, 0 );
    HANDLE  hThread = 0;
    BOOL fSuccess = FALSE;

    if ( IsValidHandle(hSnapshot) )
    {
        THREADENTRY32   te;

        te.dwSize = sizeof(te);
        fSuccess = Thread32First( hSnapshot, &te );
        while ( fSuccess )
        {
            if ( te.th32OwnerProcessID == dwProcessId )
            {
                hThread = OpenThread(
                    THREAD_SUSPEND_RESUME | THREAD_QUERY_INFORMATION |
                    THREAD_GET_CONTEXT | THREAD_SET_CONTEXT,
                    FALSE, te.th32ThreadID );
                if ( IsValidHandle(hThread) )
                    break;
            }

            fSuccess = Thread32Next( hSnapshot, &te );
        }

        CloseHandle( hSnapshot );
    }

    if ( fSuccess )
    {
        CONTEXT aContext;

        if ( SuspendThread( hThread ) != (DWORD)-1 )
        {
            ZeroMemory( &aContext, sizeof(aContext) );
            aContext.ContextFlags = CONTEXT_FULL;

            fSuccess = GetThreadContext( hThread, &aContext );

            if ( fSuccess )
            {
#if defined(INTEL)
                if ( sig )
                {
                    DWORD   dwStackBuffer[] =
                    {
                        aContext.Eip,
                        SignalToExceptionCode( sig ),
                        EXCEPTION_NONCONTINUABLE,
                        0,
                        0
                    };

                    aContext.Esp -= sizeof(dwStackBuffer);
                    WriteProcessMemory( hProcess, (LPVOID)aContext.Esp, dwStackBuffer, sizeof(dwStackBuffer), NULL );
                    aContext.Eip = (DWORD)GetProcAddressEx( hProcess, GetModuleHandleA("KERNEL32"), "RaiseException" );
                }
                else
                {
                    // FIXME: why? Does AMD64 need it too?
                    aContext.Ecx = aContext.Eax = aContext.Ebx = aContext.Edx = aContext.Esi = aContext.Edi = 0;
                }
#elif defined(X86_64)
                if ( sig )
                {
                    DWORD   dwStackBuffer[] =
                    {
                        (DWORD)(aContext.Rip >> 32),
                        (DWORD)(aContext.Rip),
                        SignalToExceptionCode( sig ),
                        EXCEPTION_NONCONTINUABLE,
                        0,
                        0,
                        0
                    };

                    aContext.Rsp -= sizeof(dwStackBuffer);
                    WriteProcessMemory( hProcess, (LPVOID)aContext.Rsp, dwStackBuffer, sizeof(dwStackBuffer), NULL );
                    aContext.Rip = (DWORD64) GetProcAddressEx( hProcess, GetModuleHandleA("KERNEL32"), "RaiseException" );
                }
#endif

                fSuccess = SetThreadContext( hThread, &aContext );
            }

            fSuccess = ResumeThread( hThread ) && fSuccess;

            DWORD   dwLastError = GetLastError();
            CloseHandle( hThread );
            SetLastError( dwLastError );

            return fSuccess;
        }
    }

    return FALSE;
}
/////////////////////////////////////////////////////////////////////////////
// Command line parameter parsing
/////////////////////////////////////////////////////////////////////////////

static void ParseCommandArgs( LPDWORD lpProcesses, LPDWORD lpdwNumProcesses, int *pSig )
{
    typedef struct _SignalEntry
    {
        LPCTSTR lpSignalName;
        int iSignalValue;
    } SignalEntry;

    #define SIG_ENTRY( signal ) { TEXT(#signal), SIG##signal }

    static SignalEntry SupportedSignals[] =
    {
        SIG_ENTRY( NULL ),
        SIG_ENTRY( SEGV ),
        SIG_ENTRY( ILL ),
        SIG_ENTRY( FPE ),
        SIG_ENTRY( INT ),
        SIG_ENTRY( BREAK ),
        SIG_ENTRY( TERM ),
        SIG_ENTRY( ABRT ),
        SIG_ENTRY( KILL )
    };

    const int NumSupportedSignals = elementsof(SupportedSignals);

    DWORD   dwMaxProcesses = *lpdwNumProcesses;
    int     argc = __argc;
    TCHAR   **argv = __targv;

    *lpdwNumProcesses = 0;

    for ( int argn = 1; argn < argc; argn++ )
    {
        if ( 0 == lstrcmpi( argv[argn], TEXT("-l") ) ||
             0 == lstrcmpi( argv[argn], TEXT("/l") ) )

        {
            for ( int n = 0; n < NumSupportedSignals; n++ )
            {
                _tprintf( _T("%s "), SupportedSignals[n].lpSignalName );
            }
            _tprintf( _T("\n") );
            ExitProcess( 0 );
        }
        else if ( 0 == lstrcmpi( argv[argn], TEXT("-?") ) ||
                  0 == lstrcmpi( argv[argn], TEXT("/?") ) ||
                  0 == lstrcmpi( argv[argn], TEXT("-h") ) ||
                  0 == lstrcmpi( argv[argn], TEXT("/h") ) ||
                  0 == lstrcmpi( argv[argn], TEXT("--help") ) )
        {
            _tprintf(
                _T("Terminates a process by sending a signal.\n\n")
                _T("Usage: kill [ -l ] [ -signal ] pid ...\n\n")
                _T("-l        Lists supported signals\n")
                _T("-signal   Sends the specified signal to the given processes.\n")
                _T("          signal can be a numeric value specifying the signal number\n")
                _T("          or a string listed by the -l parameter. If no signal is\n")
                _T("          given SIGTERM (-TERM) is used.\n")
                _T("pid       Process id(s) or executables names(s) of processes to \n")
                _T("          signal or terminate.\n\n")
                );
            ExitProcess( 0 );
        }
        else if ( argv[argn] && ( *argv[argn] == '-' || *argv[argn] == '/' ) )
        {
            LPCTSTR argsig = CharNext( argv[argn] );

            int n;
            for ( n = 0; n < NumSupportedSignals; n++ )
            {
                _TCHAR *endptr = NULL;

                if ( 0 == lstrcmpi( SupportedSignals[n].lpSignalName, argsig ) ||
                     _tcstoul( argsig, &endptr, 0 ) == static_cast< unsigned >(SupportedSignals[n].iSignalValue) && (!endptr || !*endptr) )
                {
                    *pSig = SupportedSignals[n].iSignalValue;
                    break;
                }
            }

            if ( n >= NumSupportedSignals )
            {
                _ftprintf( stderr,
                    _T("kill: Illegal argument %s\n")
                    _T("Type 'kill --help' to show allowed syntax.\n")
                    _T("Type 'kill -l' to show supported signals.\n"),
                    argv[argn] );
                ExitProcess( 0 );
            }
        }
        else
        {
            unsigned long value = 0;
            _TCHAR  *endptr = NULL;

            value = _tcstoul( argv[argn], &endptr, 0 );

            if ( !endptr || !*endptr )
            {
                if ( *lpdwNumProcesses < dwMaxProcesses )
                {
                    *(lpProcesses++) = value;
                    (*lpdwNumProcesses)++;
                }
            }
            else
            {
                HANDLE  hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );

                if ( IsValidHandle( hSnapshot ) )
                {
                    PROCESSENTRY32  pe;

                    pe.dwSize = sizeof(pe);
                    BOOL fSuccess = Process32First( hSnapshot, &pe );

                    while ( fSuccess )
                    {
                        if ( 0 == lstrcmpi( argv[argn], pe.szExeFile ) )
                        {
                            if ( *lpdwNumProcesses < dwMaxProcesses )
                            {
                                *(lpProcesses++) = pe.th32ProcessID;
                                (*lpdwNumProcesses)++;
                            }
                        }
                        fSuccess = Process32Next( hSnapshot, &pe );
                    }

                    CloseHandle( hSnapshot );
                }
            }
        }
    }

    if ( !*lpdwNumProcesses )
    {
        _ftprintf( stderr,
            _T("kill: No process specified.\n")
            _T("Use kill --help to show allowed syntax.\n")
            );
        ExitProcess( 0 );
    }

}

void OutputSystemMessage( DWORD dwErrorCode )
{
    LPVOID lpMsgBuf;
    FormatMessageA(
                    FORMAT_MESSAGE_ALLOCATE_BUFFER |
                    FORMAT_MESSAGE_FROM_SYSTEM |
                    FORMAT_MESSAGE_IGNORE_INSERTS,
                    NULL,
                    dwErrorCode,
                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                    (LPSTR)&lpMsgBuf,
                    0,
                    NULL
                );

    printf( (LPSTR)lpMsgBuf );
    LocalFree( lpMsgBuf );
}

int _tmain()
{
    DWORD   dwProcessIds[1024];
    DWORD   nProcesses = elementsof(dwProcessIds);
    int     sig = SIGTERM;


    ParseCommandArgs( dwProcessIds, &nProcesses, &sig );

    for ( ULONG n = 0; n < nProcesses; n++ )
    {
        HANDLE  hProcess;

        _tprintf( _T("Sending signal to process id %d..."), dwProcessIds[n] );
        hProcess = OpenProcess( PROCESS_TERMINATE | PROCESS_CREATE_THREAD | SYNCHRONIZE |
            PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_VM_READ,
            FALSE, dwProcessIds[n] );

        if ( IsValidHandle( hProcess ) )
        {
            if ( SIGKILL == sig )
                TerminateProcess( hProcess, 255 );
            else
            {
                if ( RaiseSignalEx( hProcess, sig ) )
                    _tprintf( _T("OK\n") );
                else
                {
                    OutputSystemMessage( GetLastError() );
                }
            }

            CloseHandle( hProcess );
        }
        else
        {
            OutputSystemMessage( GetLastError() );
        }
    }

    return 0;
}