COM function that return BSTR** does not work as it seems to me it should , but same function not from COM work like expected

huangapple
go评论95阅读模式
英文:

COM function that return BSTR** does not work as it seems to me it should , but same function not from COM work like expected

问题

  1. 我正在尝试编写一个具有Windows服务管理功能的COM对象。为此，我想要一个返回所有服务名称的函数。我已经熟悉Windows Api几天了，所以我不太明白我在做什么（错误）以及如何更好地完成它。
  3. 在另一个程序中，我以以下方式调用这个函数：
  5. ```c
  6. ...
  7.     BSTR* pServiceNames = (BSTR*)CoTaskMemAlloc(sizeof(BSTR));;
  8.     DWORD dwServicesReturned = 0;
  9.     hr = pIService->GetServices(&pServiceNames, &dwServicesReturned);
  10. ...

然后我尝试类似这样：

  1. std::wcout << (pServiceNames[0]);  // 结果: AdobeARMservice
  2. std::wcout << (pServiceNames[1]);  // 结果: (进程 8844) 以代码 -1073741819 退出。

如果使用 "printf" 也是一样的。

  1. std::cout << (pServiceNames[1]); // 结果: 000000084D454D4C

当我将相同的函数粘贴到我的主程序中时，一切正常，即所有服务名称都会显示出来。

附加信息：对于COM，我使用了ATL，也许这很重要。

  2. <details>
  3. <summary>英文:</summary>
  5. I am trying to write a COM object with Windows Service Managment functionality. For this, I want a function that returns the names of all services. I&#39;ve been familiar with Windows Api for a few days, so I don&#39;t really understand what I&#39;m doing (wrong) and how I can do it better.

STDMETHODIMP CServiceHandler::GetServices(BSTR** pOut, LPDWORD dwServicesReturned)
{
SC_HANDLE hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE);
if (!hSCManager)
{

  1.     return HRESULT_FROM_WIN32(GetLastError());
  2. }
  4. DWORD dwBytesNeeded = 0;
  5. DWORD dwResumeHandle = 0;
  7. EnumServicesStatus(hSCManager, SERVICE_WIN32, SERVICE_STATE_ALL, NULL, 0, &amp;dwBytesNeeded, dwServicesReturned, &amp;dwResumeHandle);
  9. if (GetLastError() != ERROR_MORE_DATA)
  10. {
  12.     CloseServiceHandle(hSCManager);
  13.     return HRESULT_FROM_WIN32(GetLastError());
  14. }
  16. LPENUM_SERVICE_STATUS lpServices = (LPENUM_SERVICE_STATUS)malloc(dwBytesNeeded);
  17. if (!EnumServicesStatus(hSCManager, SERVICE_WIN32, SERVICE_STATE_ALL, lpServices, dwBytesNeeded, &amp;dwBytesNeeded, dwServicesReturned, &amp;dwResumeHandle))
  18. {
  20.     free(lpServices);
  21.     CloseServiceHandle(hSCManager);
  22.     return HRESULT_FROM_WIN32(GetLastError());
  23. }
  25. BSTR* pServiceNames = (BSTR*)malloc(*dwServicesReturned * sizeof(BSTR));
  26. if (!pServiceNames)
  27. {
  28.     free(lpServices);
  29.     CloseServiceHandle(hSCManager);
  30.     return E_OUTOFMEMORY;
  31. }
  33. ZeroMemory(pServiceNames, *dwServicesReturned * sizeof(BSTR));
  37. for (DWORD i = 0; i &lt; *dwServicesReturned; i++)
  38. {
  39.     
  40.     pServiceNames[i] = SysAllocString(lpServices[i].lpServiceName);
  41. }
  43.   *pOut = pServiceNames;

// //return S_OK;
free(lpServices);

  1.   CloseServiceHandle(hSCManager);
  2.   return S_OK;
  2. In another program where I call this function this way:

...
BSTR* pServiceNames = (BSTR*)CoTaskMemAlloc(sizeof(BSTR));;
DWORD dwServicesReturned = 0;
hr = pIService->GetServices(&pServiceNames, &dwServicesReturned);
...

  1. Then I try something like this:
  3. `std::wcout &lt;&lt; (pServiceNames[0]);  // result: AdobeARMservice`
  5. `std::wcout &lt;&lt; (pServiceNames[1]);  // result: (process 8844) exited with code -1073741819.`
  7. Same if use &quot;printf&quot;. And
  8. `std::cout &lt;&lt; (pServiceNames[1]); //result: 000000084D454D4C`
  15.  
  17. When I paste the same function into my main program, everything is fine, i.e. all the service names are displayed.
  19. Additional information: For COM I used ATL, maybe it&#39;s important.
  22. </details>
  25. # 答案1
  26. **得分**: 1
  28. 你对`EnumServiceStatus()`的处理不完整，因为你没有考虑`ERROR_INSUFFICIENT_BUFFER`。对`EnumServiceStatus()`的每次调用可能需要更多内存，因此可能报告`ERROR_INSUFFICIENT_BUFFER`，或者可能只返回部分数据，报告`ERROR_MORE_DATA`。你需要处理这两种情况，以及当报告`ERROR_MORE_DATA`时，可能已返回一些有效数据，需要进行处理。因此，在枚举过程中，可能需要多次重新分配你的`BSTR`数组。
  30. 此外，在COM中传递的所有内存都需要使用COM的内存管理器分配，但`GetServices()`正在使用`malloc()`分配输出的`BSTR`数组。你的调用代码在调用`GetServices()`之前本地调用了`CoTaskMemAlloc()`，然后`GetServices()`覆盖了调用者的指针，从而泄漏了调用者分配的内存。调用者不应该在本地分配任何内存，只需接管`GetServices()`输出的内存。
  32. 有了这些信息，你可以尝试像这样改进代码：
  34. ```cpp
  35. STDMETHODIMP CServiceHandler::GetServices(BSTR** pServices, LPDWORD pdwServicesReturned)
  36. {
  37. 	if (!(pServices && pdwServicesReturned))
  38. 		return E_POINTER;
  40. 	*pServices = NULL;
  41. 	*pdwServicesReturned = 0;
  43. 	SC_HANDLE hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE);
  44. 	if (!hSCManager)
  45. 		return HRESULT_FROM_WIN32(GetLastError());
  47. 	LPENUM_SERVICE_STATUS lpStatuses = NULL;
  48. 	DWORD dwBytesAllocated = 0;
  49. 	DWORD dwBytesNeeded = 0;
  50. 	DWORD dwNumStatuses = 0;
  51. 	DWORD dwResumeHandle = 0;
  53. 	BSTR* pServiceNames = NULL;
  54. 	DWORD dwNumServiceNames = 0;
  56. 	BOOL bSuccess;
  57. 	DWORD dwError = 0;
  58. 	HRESULT hRes = S_OK;
  60. 	do
  61. 	{
  62. 		bSuccess = EnumServicesStatus(hSCManager, SERVICE_WIN32, SERVICE_STATE_ALL, lpStatuses, dwBytesAllocated, &dwBytesNeeded, &dwNumStatuses, &dwResumeHandle);
  63. 		if (!bSuccess)
  64. 		{
  65. 			dwError = GetLastError();
  66. 			if ((dwError != ERROR_INSUFFICIENT_BUFFER) &&
  67. 				(dwError != ERROR_MORE_DATA))
  68. 			{
  69. 				hRes = HRESULT_FROM_WIN32(dwError);
  70. 				goto Failed;
  71. 			}
  72. 		}
  74. 		if ((bSuccess || (dwError == ERROR_MORE_DATA)) &&
  75. 			(dwNumStatuses > 0))
  76. 		{
  77. 			BSTR* pTmpServiceNames = (BSTR*)CoTaskMemRealloc(pServiceNames, sizeof(BSTR) * (dwNumServiceNames + dwNumStatuses));
  78. 			if (!pTmpServiceNames)
  79. 			{
  80. 				hRes = E_OUTOFMEMORY;
  81. 				goto Failed;
  82. 			}
  83. 			pServiceNames = pTmpServiceNames;
  85. 			for (DWORD i = 0; i < dwNumStatuses; ++i)
  86. 			{
  87. 				pServiceNames[dwNumServiceNames] = SysAllocString(lpStatuses[i].lpServiceName);
  88. 				if (!pServiceNames[dwNumServiceNames])
  89. 				{
  90. 					hRes = E_OUTOFMEMORY;
  91. 					goto Failed;
  92. 				}
  93. 				++dwNumServiceNames;
  94. 			}
  95. 		}
  97. 		if (!bSuccess)
  98. 		{
  99. 			LPENUM_SERVICE_STATUS lpTmpStatuses = (LPENUM_SERVICE_STATUS)realloc(lpStatuses, dwBytesNeeded);
  100. 			if (!lpTmpStatuses)
  101. 			{
  102. 				hRes = E_OUTOFMEMORY;
  103. 				goto Failed;
  104. 			}
  105. 			lpStatuses = lpTmpStatuses;
  106. 		}
  107. 	} while (!bSuccess);
  109. 	goto Finished;
  111. Failed:
  112. 	if (pServiceNames)
  113. 	{
  114. 		for (DWORD i = 0; i < dwNumServiceNames; ++i)
  115. 			SysFreeString(pServiceNames[i]);
  116. 		CoTaskMemFree(pServiceNames);
  117. 		pServiceNames = NULL;
  118. 	}
  119. 	dwNumServiceNames = 0;
  121. Finished:
  122. 	free(lpStatuses);
  123. 	CloseServiceHandle(hSCManager);
  125. 	*pServices = pServiceNames;
  126. 	*pdwServicesReturned = dwNumServiceNames;
  128. 	return hRes;
  129. }
  1. BSTR* pServiceNames = NULL;
  2. DWORD dwServicesReturned = 0;
  3. hr = pIService->GetServices(&pServiceNames, &dwServicesReturned);
  4. if (hr == S_OK)
  5. {
  6. 	...
  7. 	for (DWORD i = 0; i < dwServicesReturned; ++i)
  8. 		SysFreeString(pServiceNames[i]);
  9. 	CoTaskMemFree(pServiceNames);
  10. }

或者，既然你将问题标记为C++，你应该使用C++习惯来更有效地管理内存，例如：

  1. struct SCHandle
  2. {
  3. 	SC_HANDLE m_SC;
  5. 	SCHandle(SC_HANDLE hSC) : m_SC(hSC) {}
  6. 	~SCHandle() { if (m_SC) CloseServiceHandle(m_SC); }
  8. 	bool operator !() const { return !m_SC; }
  9. 	operator SC_HANDLE() { return m_SC; }
  10. };
  12. STDMETHODIMP CServiceHandler::GetServices(BSTR** pServices, LPDWORD pdwServicesReturned)
  13. {
  14. 	if (!(pServices && pdwServicesReturned))
  15. 		return E_POINTER;
  17. 	try
  18. 	{
  19. 		*pServices = NULL;
  20. 		*pdwServicesReturned = 0;
  22. 		SCHandle hSCManager(OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE));
  23. 		if (!hSCManager)
  24. 			return HRESULT_FROM_WIN32(GetLastError());
  26. 		std::vector<BYTE> statusBuffer;
  27. 		std::vector<std::wstring> serviceNames;
  29. 		LPENUM_SERVICE_STATUS lpStatuses = NULL;
  30. 		DWORD dwBytesNeeded = 0;
  31. 		DWORD dwNumStatuses = 0;
  32. 		DWORD dwResumeHandle = 0;
  34. 		DWORD dwError = 0;
  36. 		do
  37. 		{
  38. 			BOOL bSuccess = EnumServicesStatus(hSCManager, SERVICE_WIN32, SERVICE_STATE_ALL, lpStatuses, statusBuffer.size(), &dwBytesNeeded, &dwNumStatuses, &dwResumeHandle);
  39. 			if (!bSuccess)
  40. 			{
  41. 				dwError = GetLastError();
  42. 				if ((dwError != ERROR_INSUFFICIENT_BUFFER) &&
  43. 					(dwError != ERROR_MORE_DATA))
  44. 					return HRESULT_FROM_WIN32(dwError);
  45. 			}
  47. 			if (bSuccess || (dwError == ERROR_MORE_DATA))
  48. 			{
  49. 				serviceNames.reserve(serviceNames.size() + dwNumStatuses);
  51. 				for (DWORD i = 0; i < dwNumStatuses; ++i)
  52. 					serviceNames.push_back(lpStatuses[i].lpServiceName);
  53. 			}
  55. 			if (!bSuccess)
  56. 			{
  57. 				statusBuffer.resize(dwBytesNeeded);
  58. 				lpStatuses = reinterpret_cast<LPENUM_SERVICE_STATUS>(statusBuffer.data());
  59. 			}
  60. 		} while (!bSuccess);
  62. 		DWORD dwNumServiceNames =
  64. <details>
  65. <summary>英文:</summary>
  67. Your handling of `EnumServiceStatus()` is incomplete, as you are not taking `ERROR_INSUFFICIENT_BUFFER` into account.  Any given call to `EnumServiceStatus()` may require more memory, thus reporting `ERROR_INSUFFICIENT_BUFFER`, or it may return only a subset of data, reporting `ERROR_MORE_DATA`. You need to handle both cases, as well as the fact that when `ERROR_MORE_DATA` is reported, some valid data may have been returned which you need to process.  So, you may end up having to reallocate your `BSTR` array more than once during the course of your enumeration.
  69. Also, all memory passed around in COM needs to be allocated with COM&#39;s memory manager, but `GetServices()` is allocating the output `BSTR` array using `malloc()`.  Your calling code is calling `CoTaskMemAlloc()` locally before calling `GetServices()`, and then `GetServices()` is overwriting the caller&#39;s pointer, thus leaking the memory that the caller allocated.  The caller should not be allocating any memory locally at all, only taking ownership of the memory that `GetServices()` outputs.
  71. With that said, try something more like this:

STDMETHODIMP CServiceHandler::GetServices(BSTR** pServices, LPDWORD pdwServicesReturned)
{
if (!(pServices && pdwServicesReturned))
return E_POINTER;

  1. *pServices = NULL;
  2. *pdwServicesReturned = 0;
  3. SC_HANDLE hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE);
  4. if (!hSCManager)
  5. return HRESULT_FROM_WIN32(GetLastError());
  6. LPENUM_SERVICE_STATUS lpStatuses = NULL;
  7. DWORD dwBytesAllocated = 0;
  8. DWORD dwBytesNeeded = 0;
  9. DWORD dwNumStatuses = 0;
  10. DWORD dwResumeHandle = 0;
  11. BSTR* pServiceNames = NULL;
  12. DWORD dwNumServiceNames = 0;
  13. BOOL bSuccess;
  14. DWORD dwError = 0;
  15. HRESULT hRes = S_OK;
  16. do
  17. {
  18. bSuccess = EnumServicesStatus(hSCManager, SERVICE_WIN32, SERVICE_STATE_ALL, lpStatuses, dwBytesAllocated, &amp;dwBytesNeeded, &amp;dwNumStatuses, &amp;dwResumeHandle);
  19. if (!bSuccess)
  20. {	
  21. dwError = GetLastError();
  22. if ((dwError != ERROR_INSUFFICIENT_BUFFER) &amp;&amp;
  23. (dwError != ERROR_MORE_DATA))
  24. {
  25. hRes = HRESULT_FROM_WIN32(dwError);
  26. goto Failed;
  27. }
  28. }
  29. if ((bSuccess || (dwError == ERROR_MORE_DATA)) &amp;&amp;
  30. (dwNumStatuses &gt; 0))
  31. {
  32. BSTR *pTmpServiceNames = (BSTR*) CoTaskMemRealloc(pServiceNames, sizeof(BSTR) * (dwNumServiceNames + dwNumStatuses));
  33. if (!pTmpServiceNames)
  34. {
  35. hRes = E_OUTOFMEMORY;
  36. goto Failed;
  37. }
  38. pServiceNames = pTmpServiceNames;
  39. for (DWORD i = 0; i &lt; dwNumStatuses; ++i)
  40. {
  41. pServiceNames[dwNumServiceNames] = SysAllocString(lpStatuses[i].lpServiceName);
  42. if (!pServiceNames[dwNumServiceNames])
  43. {
  44. hRes = E_OUTOFMEMORY;
  45. goto Failed;
  46. }
  47. ++dwNumServiceNames;
  48. }
  49. }
  50. if (!bSuccess)
  51. {
  52. LPENUM_SERVICE_STATUS lpTmpStatuses = (LPENUM_SERVICE_STATUS) realloc(lpStatuses, dwBytesNeeded);
  53. if (!lpTmpStatuses)
  54. {
  55. hRes = E_OUTOFMEMORY;
  56. goto Failed;
  57. }
  58. lpStatuses = lpTmpStatuses;
  59. }
  60. }
  61. while (!bSuccess);
  62. goto Finished;

Failed:
if (pServiceNames)
{
for (DWORD i = 0; i < dwNumServiceNames; ++i)
SysFreeString(pServiceNames[i]);
CoTaskMemFree(pServiceNames);
pServiceNames = NULL;
}
dwNumServiceNames = 0;

Finished:
free(lpStatuses);
CloseServiceHandle(hSCManager);

  1. *pServices = pServiceNames;
  2. *pdwServicesReturned = dwNumServiceNames;
  3. return hRes;

}

BSTR* pServiceNames = NULL;
DWORD dwServicesReturned = 0;
hr = pIService->GetServices(&pServiceNames, &dwServicesReturned);
if (hr == S_OK)
{
...
for(DWORD i = 0; i < dwServicesReturned; ++i)
SysFreeString(pServiceNames[i]);
CoTaskMemFree(pServiceNames);
}

  2. Alternatively, since you did tag the question as C++, you should use C++ idioms to help manage memory more effectively, eg:

struct SCHandle
{
SC_HANDLE m_SC;

  1. SCHandle(SC_HANDLE hSC) : m_SC(hSC) {}
  2. ~SCHandle() { if (m_SC) CloseServiceHandle(m_SC); }
  3. bool operator !() const { return !m_SC; }
  4. operator SC_HANDLE() { return m_SC; }

};

STDMETHODIMP CServiceHandler::GetServices(BSTR** pServices, LPDWORD pdwServicesReturned)
{
if (!(pServices && pdwServicesReturned))
return E_POINTER;

  1. try
  2. {
  3. *pServices = NULL;
  4. *pdwServicesReturned = 0;
  5. SCHandle hSCManager(OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE));
  6. if (!hSCManager)
  7. return HRESULT_FROM_WIN32(GetLastError());
  8. std::vector&lt;BYTE&gt; statusBuffer;
  9. std::vector&lt;std::wstring&gt; serviceNames;
  10. LPENUM_SERVICE_STATUS lpStatuses = NULL;
  11. DWORD dwBytesNeeded = 0;
  12. DWORD dwNumStatuses = 0;
  13. DWORD dwResumeHandle = 0;
  14. DWORD dwError = 0;
  15. do
  16. {
  17. BOOL bSuccess = EnumServicesStatus(hSCManager, SERVICE_WIN32, SERVICE_STATE_ALL, lpStatuses, statusBuffer.size(), &amp;dwBytesNeeded, &amp;dwNumStatuses, &amp;dwResumeHandle);
  18. if (!bSuccess)
  19. {	
  20. dwError = GetLastError();
  21. if ((dwError != ERROR_INSUFFICIENT_BUFFER) &amp;&amp;
  22. (dwError != ERROR_MORE_DATA))
  23. return HRESULT_FROM_WIN32(dwError);
  24. }
  25. if (bSuccess || (dwError == ERROR_MORE_DATA))
  26. {
  27. serviceNames.reserve(serviceNames.size() + dwNumStatuses);
  28. for (DWORD i = 0; i &lt; dwNumStatuses; ++i)
  29. serviceNames.push_back(lpStatuses[i].lpServiceName);
  30. }
  31. if (!bSuccess)
  32. {
  33. statusBuffer.resize(dwBytesNeeded);
  34. lpStatuses = reinterpret_cast&lt;LPENUM_SERVICE_STATUS&gt;(statusBuffer.data());
  35. }
  36. }
  37. while (!bSuccess);
  38. DWORD dwNumServiceNames = serviceNames.size();
  39. BSTR *pServiceNames = static_cast&lt;BSTR*&gt;(CoTaskMemAlloc(sizeof(BSTR) * dwNumServiceNames));
  40. if (!pServiceNames)
  41. return E_OUTOFMEMORY;
  42. for (DWORD i = 0; i &lt; dwNumServiceNames; ++i)
  43. {
  44. pServiceNames[i] = SysAllocString(serviceNames[i].c_str());
  45. if (!pServiceNames[i])
  46. {
  47. for(DWORD j = 0; j &lt; i; ++j)
  48. SysFreeString(pServiceNames[j]);
  49. CoTaskMemFree(pServiceNames);
  50. return E_OUTOFMEMORY;
  51. }
  52. }
  53. *pServices = pServiceNames;
  54. *pdwServicesReturned = dwNumServiceNames;
  55. return S_OK;
  56. }
  57. catch (const std::bad_alloc &amp;)
  58. {
  59. return E_OUTOFMEMORY;
  60. }
  61. catch (...)
  62. {
  63. return E_UNEXPECTED;
  64. }

}

  2. </details>

huangapple
  • 本文由 发表于 2023年2月23日 21:44:10
  • 转载请务必保留本文链接：https://go.coder-hub.com/75545659.html
  • c++
  • com
  • service
  • winapi
  • windows
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定