c - 如何将句柄传递给子进程

Question

我正在尝试通过命令行或任何其他方式将互斥锁句柄传递给子进程。

我该怎么做？我如何访问 child 的互斥量？

这就是我创建子进程的方式:

HANDLE ghMutex;

     if( !CreateProcess( _T("C:\\Users\\Kumppler\\Documents\\Visual Studio 2010\\Projects\\teste3\\Debug\\teste3.exe"),   // No module name (use command line)
                aux2,                              // Command line
                NULL,                              // Process handle not inheritable
                NULL,                              // Thread handle not inheritable
                TRUE,                              // Set handle inheritance to TRUE
                STARTF_USESTDHANDLES,              // inherit the standard input, standard output, and standard error handles
                NULL,                              // Use parent's environment block
                NULL,                              // Use parent's starting directory 
                &si[j],                            // Pointer to STARTUPINFO structure
                &pi[j] )                           // Pointer to PROCESS_INFORMATION structure
            )                     

编辑:

我需要为多个子进程使用互斥锁，可以吗？

所以这是我现在正在做的:

HANDLE ghMutex;
int mutex;
char mutexstring[7];

mutex=(int)ghMutex;
itoa(mutexValue,mutexString,10);

我将通过命令行传递 mutexString，然后在子进程中将其转换回:

mutexValue=atoi(argv[2]);

Mutex=(HANDLE)mutexValue;

我的问题是，可以进行 (HANDLE) 转换吗？？

Answer 1

两种选择:

1. 您可以使用命名对象。进程 A 创建具有名称的 Mutex，然后生成进程 B。进程 B 然后调用具有相同名称的 OpenMutex 或 CreateMutex，它将获得相同互斥量的句柄。

   缺点是名字的选择。如果发生名称冲突，您可能会得到不可预知的结果。攻击者可以创建具有相同名称的互斥量并造成拒绝服务情况。处理此问题的一种方法是随机生成名称。例如，进程 A 可以为该名称生成一个 GUID，然后将该 GUID(作为字符串)在命令行上传递给进程 B。

2. 您可以使用 inheritance .子进程可以从父进程继承多种类型的句柄，包括互斥句柄。在 CreateProcess 命令中设置 bInheritHandles 参数(您的示例已经在执行此操作)，并将命令行上的句柄值(作为字符串)传递给子进程。然后子进程可以将命令行字符串转换回一个值并简单地开始使用它。两个进程中的值相同。

此技术没有命名对象技术的缺点。

一个继承的工作示例(省略了错误检查):

#include <cstddef>
#include <iostream>
#include <string>
#include <sstream>
#include <windows.h>

void DoParentWork() {
  std::wcout << L"Parent:  Creating an inheritable event..." << std::endl;
  SECURITY_ATTRIBUTES security = {
    sizeof(security), nullptr, /* bInheritHandle = */ TRUE
  };
  HANDLE hEvent = ::CreateEventW(&security, /* bManualReset = */ TRUE,
                                 /* bInitialState = */ FALSE, nullptr);

  std::wstringstream ssCommand;
  ssCommand << L"foo.exe " << reinterpret_cast<std::size_t>(hEvent);
  std::wstring strCmd = ssCommand.str();;

  std::wcout << L"Parent:  Starting child process..." << std::endl;
  STARTUPINFO start_info = {sizeof(start_info)};
  PROCESS_INFORMATION proc_info = {0};
  ::CreateProcessW(L"foo.exe", &strCmd[0], nullptr, nullptr,
                   /* bInheritHandles = */ TRUE, 0, nullptr, nullptr,
                   &start_info, &proc_info);
  ::CloseHandle(proc_info.hThread);
  ::CloseHandle(proc_info.hProcess);

  std::wcout << L"Parent:  Waiting for the child to signal the event."
             << std::endl;
  if (::WaitForSingleObject(hEvent, 10*1000) == WAIT_OBJECT_0) {
    std::wcout << L"Parent:  The event was signaled." << std::endl;
  } else {
    std::wcout << L"Parent:  Timed out waiting for the event."
               << std::endl;
  }
  ::CloseHandle(hEvent);
}

void DoChildWork(const char *pszEvent) {
  std::stringstream ss(pszEvent);
  UINT_PTR iEvent;
  ss >> iEvent;
  HANDLE hEvent = reinterpret_cast<HANDLE>(iEvent);
  std::cout << "Child:  Event handle "
            << reinterpret_cast<std::size_t>(hEvent) << std::endl;
  ::Sleep(2000);
  std::cout << "Child:  Signalling the event." << std::endl;
  ::SetEvent(hEvent);
}

int main(int cArgs, char *ppszArgs[]) {
  if (cArgs > 1) DoChildWork(ppszArgs[1]);
  else DoParentWork();
  return 0;
}