如何通过父进程句柄获取子进程句柄？

本篇文章向大家介绍《如何通过父进程句柄获取子进程句柄？》，主要包括，具有一定的参考价值，需要的朋友可以参考一下。

在 windows 10 上，我想在每个子/孙进程上使用 ntsuspendprocess 挂起整个进程树。

我正在使用 exec.command("java", ...) 启动父进程，进程树应如下所示：

myapp (executes cmd.start())
   \__java (parent)
        \__java
             |__proc1
             \__proc2

我可以通过以下方式检索进程父句柄 uintptr：

cmd := exec.Command("java", ...)
cmd.Start()
// mirror os.Process struct
type osprocmirror struct {
    Pid    int
    handle uintptr
    isdone uint32
    sigMu  sync.RWMutex
}
handle := (*osprocmirror)(unsafe.Pointer(cmd.Process))

我不知道如何从父句柄（或 pid）检索子进程的句柄，以便单独挂起它们。

（由于不存在一起暂停所有父进程和子进程的选项，所以我应该一一暂停，对吧？）

• 我尝试列出所有进程，然后仅选择具有正确父 pid 的进程，但我找不到通过了解子 pid 可靠地获取父 pid 的方法（另外，如果是孙子进程，还会出现问题） ，另外我更喜欢专门使用手柄，这应该更可靠）。
• 我尝试创建一个作业，在其中生成第一个进程，以便能够使用作业句柄列出所有子 pid/句柄，但它非常复杂，并且需要一些低级实现（这不需要非常适合 os.exec 包）。
• 我从 user32.dll 中找到了一个名为 enumchildwindows 的 windows 函数，并开始实现它，但由于我不完全理解它是如何工作的（它只适用于具有图形窗口的进程吗？因为我不使用 gui根本），我想知道其他可能的解决方案（也许更简单）。

是否有更简单的方法从父进程获取所有子进程句柄？

如果没有，您是否有此类实现的一些很好的示例？

谢谢

正确答案

我创建了一个小脚本来执行此操作（检查 here）
我将其发布在这里：

// This is a script to retrieve the child processes pids of a process (retrieve the complete process tree)
// Tn this example the process identified by pid 7400 is used
// (please to run the test chose a process pid that has at least 1 child process)
// (tested on windows)

package main

import (
    "fmt"
    "syscall"
    "unsafe"
)

func main() {
    rootPid := uint32(7400)

    tree, err := getTreePids(rootPid)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println("tree [", len(tree), "]:\t", tree)
}

// getTreePids will return a list of pids that represent the tree of process pids originating from the specified one.
// (they are ordered: [parent, 1 gen child, 2 gen child, ...])
func getTreePids(rootPid uint32) ([]uint32, error) {
    // https://learn.microsoft.com/en-us/windows/win32/api/tlhelp32/ns-tlhelp32-processentry32
    procEntry := syscall.ProcessEntry32{}
    parentLayer := []uint32{rootPid}
    treePids := parentLayer
    foundRootPid := false

    snapshot, err := syscall.CreateToolhelp32Snapshot(uint32(syscall.TH32CS_SNAPPROCESS), 0)
    if err != nil {
        return nil, err
    }
    defer syscall.CloseHandle(snapshot)

    procEntry.Size = uint32(unsafe.Sizeof(procEntry))

    for {
        // set procEntry to the first process in the snapshot
        err = syscall.Process32First(snapshot, &procEntry)
        if err != nil {
            return nil, err
        }

        // loop through the processes in the snapshot, if the parent pid of the analyzed process
        // is in in the parent layer, append the analyzed process pid in the child layer
        var childLayer []uint32
        for {
            if procEntry.ProcessID == rootPid {
                foundRootPid = true
            }

            if contains(parentLayer, procEntry.ParentProcessID) {
                // avoid adding a pid if it's already contained in treePids
                // useful for pid 0 whose ppid is 0 and would lead to recursion (windows)
                if !contains(treePids, procEntry.ProcessID) {
                    childLayer = append(childLayer, procEntry.ProcessID)
                }
            }

            // advance to next process in snapshot
            err = syscall.Process32Next(snapshot, &procEntry)
            if err != nil {
                // if there aren't anymore processes to be analyzed, break out of the loop
                break
            }
        }

        // if the specified rootPid is not found, return error
        if !foundRootPid {
            return nil, fmt.Errorf("specified rootPid not found")
        }

        // fmt.Println(childLayer)

        // there are no more child processes, return the process tree
        if len(childLayer) == 0 {
            return treePids, nil
        }

        // append the child layer to the tree pids
        treePids = append(treePids, childLayer...)

        // to analyze the next layer, set the child layer to be the new parent layer
        parentLayer = childLayer
    }
}

func contains(list []uint32, e uint32) bool {
    for _, l := range list {
        if l == e {
            return true
        }
    }
    return false
}

终于介绍完啦！小伙伴们，这篇关于《如何通过父进程句柄获取子进程句柄？》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！