class.win32ps.php

Go to the documentation of this file.

<?php
/*
 *
 *  * Copyright (c) 2022-2025 Bearsampp
 *  * License: GNU General Public License version 3 or later; see LICENSE.txt
 *  * Website: https://bearsampp.com
 *  * Github: https://github.com/Bearsampp
 *
 */

class Win32Ps
{
    const NAME = 'Name';
    const PROCESS_ID = 'ProcessID';
    const EXECUTABLE_PATH = 'ExecutablePath';
    const CAPTION = 'Caption';
    const COMMAND_LINE = 'CommandLine';

    public function __construct()
    {
    }

    private static function callWin32Ps($function)
    {
        $result = false;
 
        if (function_exists($function)) {
            $result = @call_user_func($function);
        }
 
        return $result;
    }

    public static function getKeys()
    {
        return array(
            self::NAME,
            self::PROCESS_ID,
            self::EXECUTABLE_PATH,
            self::CAPTION,
            self::COMMAND_LINE
        );
    }

    public static function getCurrentPid()
    {
        $procInfo = self::getStatProc();
 
        return isset($procInfo[self::PROCESS_ID]) ? intval($procInfo[self::PROCESS_ID]) : 0;
    }

    public static function getListProcs()
    {
        $procs = Win32Native::getProcessList(self::getKeys());
 
        // Filter out processes without ExecutablePath (same behavior as old VBS version)
        if ($procs !== false && is_array($procs)) {
            $filtered = array();
            foreach ($procs as $proc) {
                if (!empty($proc[self::EXECUTABLE_PATH])) {
                    $filtered[] = $proc;
                }
            }
 
            return $filtered;
        }
 
        return $procs;
    }

    public static function getStatProc()
    {
        $statProc = self::callWin32Ps('win32_ps_stat_proc');
 
        if ($statProc !== false) {
            return array(
                self::PROCESS_ID      => $statProc['pid'],
                self::EXECUTABLE_PATH => $statProc['exe']
            );
        }
 
        return null;
    }

    public static function exists($pid)
    {
        return self::findByPid($pid) !== false;
    }

    public static function findByPid($pid)
    {
        if (!empty($pid)) {
            $procs = self::getListProcs();
            if ($procs !== false) {
                foreach ($procs as $proc) {
                    if ($proc[self::PROCESS_ID] == $pid) {
                        return $proc;
                    }
                }
            }
        }
 
        return false;
    }

    public static function findByPath($path)
    {
        $path = Path::formatUnixPath($path);
        if (!empty($path) && is_file($path)) {
            $procs = self::getListProcs();
            if ($procs !== false) {
                foreach ($procs as $proc) {
                    $unixExePath = Path::formatUnixPath($proc[self::EXECUTABLE_PATH]);
                    if ($unixExePath == $path) {
                        return $proc;
                    }
                }
            }
        }
 
        return false;
    }

    public static function kill($pid)
    {
        $pid = intval($pid);
        if (!empty($pid)) {
            Win32Native::killProcess($pid);
        }
    }

    public static function killBins($refreshProcs = false)
    {
        global $bearsamppRoot;
        $killed = array();
 
        $procs = $bearsamppRoot->getProcs();
        if ($refreshProcs || $procs === null) {
            $procs = self::getListProcs();
        }
 
        if ($procs !== false && $procs !== null) {
            foreach ($procs as $proc) {
                $unixExePath     = Path::formatUnixPath($proc[self::EXECUTABLE_PATH]);
                $unixCommandPath = Path::formatUnixPath($proc[self::COMMAND_LINE]);
 
                // Not kill current PID (PHP)
                if ($proc[self::PROCESS_ID] == self::getCurrentPid()) {
                    continue;
                }
 
                // Not kill bearsampp
                if ($unixExePath == Path::getExeFilePath()) {
                    continue;
                }
 
                // Not kill inside www
                if (UtilString::startWith($unixExePath, Path::getWwwPath() . '/') || UtilString::contains($unixCommandPath, Path::getWwwPath() . '/')) {
                    continue;
                }
 
                // Not kill external process
                if (!UtilString::startWith($unixExePath, Path::getRootPath() . '/') && !UtilString::contains($unixCommandPath, Path::getRootPath() . '/')) {
                    continue;
                }
 
                self::kill($proc[self::PROCESS_ID]);
                $killed[] = $proc;
            }
        }
 
        return $killed;
    }
}