static QString getServiceName(DWORD processId)
{
QString name;
SC_HANDLE hSCM = OpenSCManager(nullptr, nullptr, SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_CONNECT);
if (! hSCM) {
return name;
}
DWORD bufSize = 0;
DWORD servCount = 0;
EnumServicesStatusEx(hSCM, SC_ENUM_PROCESS_INFO, SERVICE_WIN32, SERVICE_STATE_ALL,
nullptr, 0, &bufSize, &servCount, nullptr, nullptr);
std::vector<BYTE> buffer(bufSize);
EnumServicesStatusEx(hSCM, SC_ENUM_PROCESS_INFO, SERVICE_WIN32, SERVICE_STATE_ALL,
buffer.data(), (DWORD)buffer.size(), &bufSize,
&servCount, nullptr, nullptr);
auto services = reinterpret_cast<LPENUM_SERVICE_STATUS_PROCESS>(buffer.data());
for (unsigned int i = 0; i < servCount; ++i) {
ENUM_SERVICE_STATUS_PROCESS service = services[i];
if (service.ServiceStatusProcess.dwProcessId == processId) {
// This is your service.
name = QString::fromUtf16((const ushort*)service.lpServiceName);
break;
}
}
CloseServiceHandle(hSCM);
return name;
}
bool mod_service::getList(vector<KIWI_SERVICE_STATUS_PROCESS> * monVectorService, wstring * machineName) // machine non implémenté
{
bool reussite = false;
DWORD error = ERROR_SUCCESS;
if(SC_HANDLE monManager = OpenSCManager(machineName ? machineName->c_str() : NULL, SERVICES_ACTIVE_DATABASE, SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE))
{
DWORD tailleRequise = 0;
DWORD nbServices = 0;
DWORD resumeHandle = 0;
if(!(EnumServicesStatusEx(monManager, SC_ENUM_PROCESS_INFO, SERVICE_DRIVER | SERVICE_WIN32, SERVICE_STATE_ALL, NULL, 0, &tailleRequise, &nbServices, &resumeHandle, NULL) != 0) && GetLastError() == ERROR_MORE_DATA)
{
BYTE * servicesBuff = new BYTE[tailleRequise];
ENUM_SERVICE_STATUS_PROCESS * mesServ = reinterpret_cast<ENUM_SERVICE_STATUS_PROCESS *>(servicesBuff);
if(reussite = EnumServicesStatusEx(monManager, SC_ENUM_PROCESS_INFO, SERVICE_DRIVER | SERVICE_WIN32, SERVICE_STATE_ALL, servicesBuff, tailleRequise, &tailleRequise, &nbServices, &resumeHandle, NULL) != 0)
{
for(DWORD i = 0; i < nbServices; i++)
{
KIWI_SERVICE_STATUS_PROCESS monService = {mesServ[i].lpServiceName, mesServ[i].lpDisplayName, mesServ[i].ServiceStatusProcess};
monVectorService->push_back(monService);
}
}
delete[] servicesBuff;
error = GetLastError();
}
CloseServiceHandle(monManager);
SetLastError(error);
}
return reussite;
}
QueryData genDrivers(QueryContext& context) {
DWORD bytesNeeded = 0;
DWORD serviceCount = 0;
std::map<std::string, std::string> loadedDrivers;
QueryData results;
// Get All Loaded Drivers including ones managed by SCM
enumLoadedDrivers(loadedDrivers);
auto schScManager = OpenSCManager(nullptr, nullptr, GENERIC_READ);
if (schScManager == nullptr) {
TLOG << "EnumServiceStatusEx failed (" << GetLastError() << ")";
return {};
}
EnumServicesStatusEx(schScManager,
SC_ENUM_PROCESS_INFO,
SERVICE_DRIVER,
SERVICE_STATE_ALL,
nullptr,
0,
&bytesNeeded,
&serviceCount,
nullptr,
nullptr);
auto buf = static_cast<PVOID>(malloc(bytesNeeded));
if (EnumServicesStatusEx(schScManager,
SC_ENUM_PROCESS_INFO,
SERVICE_DRIVER,
SERVICE_STATE_ALL,
(LPBYTE)buf,
bytesNeeded,
&bytesNeeded,
&serviceCount,
nullptr,
nullptr) != 0) {
auto services = static_cast<ENUM_SERVICE_STATUS_PROCESS*>(buf);
for (DWORD i = 0; i < serviceCount; ++i) {
queryDrvInfo(schScManager, services[i], loadedDrivers, results);
}
} else {
TLOG << "EnumServiceStatusEx failed (" << GetLastError() << ")";
}
free(buf);
CloseServiceHandle(schScManager);
for (const auto& element : loadedDrivers) {
Row r;
r["name"] = element.first;
r["path"] = element.second;
r["status"] = SQL_TEXT(kDrvStatus[4]);
results.push_back(r);
}
return results;
}
bool ServiceUtil::is_exist(const tstring& name)
{
bool bReturn = false;
do
{
scoped_scmgr_handle hSCMgr(GENERIC_READ);
if (!hSCMgr.valid())
{
break;
}
DWORD dwNeededBytes = 0;
DWORD dwReturnedSerivice = 0;
DWORD dwResumeEntryNum = 0;
if (EnumServicesStatusEx(hSCMgr.get(), SC_ENUM_PROCESS_INFO, SERVICE_DRIVER | SERVICE_WIN32,
SERVICE_STATE_ALL, NULL, 0, &dwNeededBytes, &dwReturnedSerivice, &dwResumeEntryNum, NULL))
{
ErrorLog("EnumServicesStatusEx success while query needed bytes");
break;
}
CLastErrorFormat e;
if (ERROR_MORE_DATA != e.code())
{
ErrorLogLastErrEx(e, "EnumServicesStatusEx error code is not ERROR_MORE_DATA while query needed bytes");
break;
}
boost::scoped_array<BYTE> lpData(new BYTE[dwNeededBytes]);
memset(lpData.get(), 0, dwNeededBytes);
if (!EnumServicesStatusEx(hSCMgr.get(), SC_ENUM_PROCESS_INFO, SERVICE_DRIVER | SERVICE_WIN32,
SERVICE_STATE_ALL, lpData.get(), dwNeededBytes, &dwNeededBytes, &dwReturnedSerivice, &dwResumeEntryNum, NULL))
{
ErrorLogLastErr("EnumServicesStatusEx fail");
break;
}
ENUM_SERVICE_STATUS_PROCESS *lpServiceStatus = reinterpret_cast<ENUM_SERVICE_STATUS_PROCESS *>(lpData.get());
for (DWORD dwServiceIndex = 0; dwServiceIndex != dwReturnedSerivice; ++dwServiceIndex)
{
tstring cur_name = lpServiceStatus[dwServiceIndex].lpServiceName;
if (boost::algorithm::iequals(cur_name, name))
{
bReturn = true;
break;
}
}
} while (false);
return bReturn;
}
static QString enumerateService(DWORD processId)
{
SC_HANDLE hSCM = OpenSCManager(NULL, NULL,
SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_CONNECT);
if (hSCM == NULL) {
return QString();
}
DWORD bufferSize = 0;
DWORD requiredBufferSize = 0;
DWORD totalServicesCount = 0;
EnumServicesStatusEx(hSCM,
SC_ENUM_PROCESS_INFO,
SERVICE_WIN32,
SERVICE_STATE_ALL,
NULL,
bufferSize,
&requiredBufferSize,
&totalServicesCount,
NULL,
NULL);
std::vector<BYTE> buffer(requiredBufferSize);
EnumServicesStatusEx(hSCM,
SC_ENUM_PROCESS_INFO,
SERVICE_WIN32,
SERVICE_STATE_ALL,
buffer.data(),
(DWORD)buffer.size(),
&requiredBufferSize,
&totalServicesCount,
NULL,
NULL);
QString name;
LPENUM_SERVICE_STATUS_PROCESS services =
reinterpret_cast<LPENUM_SERVICE_STATUS_PROCESS>(buffer.data());
for (unsigned int i = 0; i < totalServicesCount; ++i) {
ENUM_SERVICE_STATUS_PROCESS service = services[i];
if (service.ServiceStatusProcess.dwProcessId == processId) {
// This is your service.
name = QString::fromUtf16((const ushort*)service.lpServiceName);
break;
}
}
CloseServiceHandle(hSCM);
return name;
}
BOOL get_services(_In_ SC_HANDLE hServiceManager, _In_ DWORD serviceType, _Out_ ENUM_SERVICE_STATUS_PROCESS** servicesBuffer, _Out_ DWORD* serviceCount)
{
DWORD serviceBufferSize = 1024 * sizeof(ENUM_SERVICE_STATUS_PROCESS);
ENUM_SERVICE_STATUS_PROCESS* services = static_cast<ENUM_SERVICE_STATUS_PROCESS*>(malloc(serviceBufferSize));
if (serviceCount) //assume failure
*serviceCount = 0;
if (services) {
SecureZeroMemory(services, serviceBufferSize);
DWORD remainderBufferSize = 0;
DWORD resumeHandle = 0;
if (EnumServicesStatusEx(hServiceManager, SC_ENUM_PROCESS_INFO, serviceType, SERVICE_STATE_ALL, (LPBYTE)services, serviceBufferSize, &remainderBufferSize, serviceCount, &resumeHandle, NULL) != 0)
{
// success and we enumerated all the services
*servicesBuffer = services;
return TRUE;
}
DWORD lastError = GetLastError();
if (lastError == ERROR_MORE_DATA)
{
// we didn't get all the services, so we'll just re-enumerate all to make things easy
serviceBufferSize += remainderBufferSize;
ENUM_SERVICE_STATUS_PROCESS* tmp;
tmp = static_cast<ENUM_SERVICE_STATUS_PROCESS*>(realloc(services, serviceBufferSize));
if (tmp) {
services = tmp;
SecureZeroMemory(services, serviceBufferSize);
if (EnumServicesStatusEx(hServiceManager, SC_ENUM_PROCESS_INFO, serviceType, SERVICE_STATE_ALL, (LPBYTE)services, serviceBufferSize, &remainderBufferSize, serviceCount, NULL, NULL) != 0)
{
*servicesBuffer = services;
return TRUE;
}
}
}
else
{
printf("ERROR: %u\n", lastError);
}
free(services);
}
return FALSE;
}
int SERVICES(AGENT_REQUEST *request, AGENT_RESULT *result)
{
int start_type, service_state, ret;
char *type, *state, *exclude, *buf = NULL, *utf8;
SC_HANDLE h_mgr;
ENUM_SERVICE_STATUS_PROCESS *ssp = NULL;
DWORD sz = 0, szn, i, services, resume_handle = 0;
if (3 < request->nparam)
return SYSINFO_RET_FAIL;
type = get_rparam(request, 0);
state = get_rparam(request, 1);
exclude = get_rparam(request, 2);
if (NULL == type || '\0' == *type || 0 == strcmp(type, "all")) /* default parameter */
start_type = ZBX_SRV_STARTTYPE_ALL;
else if (0 == strcmp(type, "automatic"))
start_type = ZBX_SRV_STARTTYPE_AUTOMATIC;
else if (0 == strcmp(type, "manual"))
start_type = ZBX_SRV_STARTTYPE_MANUAL;
else if (0 == strcmp(type, "disabled"))
start_type = ZBX_SRV_STARTTYPE_DISABLED;
else
return SYSINFO_RET_FAIL;
if (NULL == state || '\0' == *state || 0 == strcmp(state, "all")) /* default parameter */
service_state = ZBX_SRV_STATE_ALL;
else if (0 == strcmp(state, "stopped"))
service_state = ZBX_SRV_STATE_STOPPED;
else if (0 == strcmp(state, "started"))
service_state = ZBX_SRV_STATE_STARTED;
else if (0 == strcmp(state, "start_pending"))
service_state = ZBX_SRV_STATE_START_PENDING;
else if (0 == strcmp(state, "stop_pending"))
service_state = ZBX_SRV_STATE_STOP_PENDING;
else if (0 == strcmp(state, "running"))
service_state = ZBX_SRV_STATE_RUNNING;
else if (0 == strcmp(state, "continue_pending"))
service_state = ZBX_SRV_STATE_CONTINUE_PENDING;
else if (0 == strcmp(state, "pause_pending"))
service_state = ZBX_SRV_STATE_PAUSE_PENDING;
else if (0 == strcmp(state, "paused"))
service_state = ZBX_SRV_STATE_PAUSED;
else
return SYSINFO_RET_FAIL;
if (NULL == (h_mgr = OpenSCManager(NULL, NULL, GENERIC_READ)))
return SYSINFO_RET_FAIL;
while (0 != (ret = EnumServicesStatusEx(h_mgr, SC_ENUM_PROCESS_INFO, SERVICE_WIN32, SERVICE_STATE_ALL,
(LPBYTE)ssp, sz, &szn, &services, &resume_handle, NULL)) || ERROR_MORE_DATA == GetLastError())
{
for (i = 0; i < services; i++)
{
SC_HANDLE h_srv;
if (NULL == (h_srv = OpenService(h_mgr, ssp[i].lpServiceName, SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG)))
continue;
if (SUCCEED == check_service_starttype(h_srv, start_type))
{
if (SUCCEED == check_service_state(h_srv, service_state))
{
utf8 = zbx_unicode_to_utf8(ssp[i].lpServiceName);
if (NULL == exclude || FAIL == str_in_list(exclude, utf8, ','))
buf = zbx_strdcatf(buf, "%s\n", utf8);
zbx_free(utf8);
}
}
CloseServiceHandle(h_srv);
}
if (0 == szn)
break;
if (NULL == ssp)
{
sz = szn;
ssp = (ENUM_SERVICE_STATUS_PROCESS *)zbx_malloc((void *)ssp, sz);
}
}
zbx_free(ssp);
CloseServiceHandle(h_mgr);
if (NULL == buf)
buf = zbx_strdup(buf, "0");
SET_STR_RESULT(result, buf);
return SYSINFO_RET_OK;
}
PVOID PhEnumServices(
_In_ SC_HANDLE ScManagerHandle,
_In_opt_ ULONG Type,
_In_opt_ ULONG State,
_Out_ PULONG Count
)
{
static ULONG initialBufferSize = 0x8000;
LOGICAL result;
PVOID buffer;
ULONG bufferSize;
ULONG returnLength;
ULONG servicesReturned;
if (!Type)
Type = WindowsVersion >= WINDOWS_10 ? SERVICE_TYPE_ALL : (SERVICE_DRIVER | SERVICE_WIN32);
if (!State)
State = SERVICE_STATE_ALL;
bufferSize = initialBufferSize;
buffer = PhAllocate(bufferSize);
if (!(result = EnumServicesStatusEx(
ScManagerHandle,
SC_ENUM_PROCESS_INFO,
Type,
State,
buffer,
bufferSize,
&returnLength,
&servicesReturned,
NULL,
NULL
)))
{
if (GetLastError() == ERROR_MORE_DATA)
{
PhFree(buffer);
bufferSize += returnLength;
buffer = PhAllocate(bufferSize);
result = EnumServicesStatusEx(
ScManagerHandle,
SC_ENUM_PROCESS_INFO,
Type,
State,
buffer,
bufferSize,
&returnLength,
&servicesReturned,
NULL,
NULL
);
}
if (!result)
{
PhFree(buffer);
return NULL;
}
}
if (bufferSize <= 0x20000) initialBufferSize = bufferSize;
*Count = servicesReturned;
return buffer;
}
void
GetServices ( void )
{
LV_ITEM item;
WORD wCodePage;
WORD wLangID;
SC_HANDLE ScHandle;
SC_HANDLE hService;
DWORD BytesNeeded = 0;
DWORD ResumeHandle = 0;
DWORD NumServices = 0;
DWORD dwHandle, dwLen;
size_t Index;
UINT BufLen;
TCHAR szStatus[128];
TCHAR* lpData;
TCHAR* lpBuffer;
TCHAR szStrFileInfo[80];
TCHAR FileName[MAX_PATH];
LPVOID pvData;
LPSERVICE_FAILURE_ACTIONS pServiceFailureActions = NULL;
LPQUERY_SERVICE_CONFIG pServiceConfig = NULL;
ENUM_SERVICE_STATUS_PROCESS *pServiceStatus = NULL;
ScHandle = OpenSCManager(NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE);
if (ScHandle != NULL)
{
if (EnumServicesStatusEx(ScHandle, SC_ENUM_PROCESS_INFO, SERVICE_WIN32, SERVICE_STATE_ALL, (LPBYTE)pServiceStatus, 0, &BytesNeeded, &NumServices, &ResumeHandle, 0) == 0)
{
/* Call function again if required size was returned */
if (GetLastError() == ERROR_MORE_DATA)
{
/* reserve memory for service info array */
pServiceStatus = HeapAlloc(GetProcessHeap(), 0, BytesNeeded);
if (!pServiceStatus)
{
CloseServiceHandle(ScHandle);
return;
}
/* fill array with service info */
if (EnumServicesStatusEx(ScHandle, SC_ENUM_PROCESS_INFO, SERVICE_WIN32, SERVICE_STATE_ALL, (LPBYTE)pServiceStatus, BytesNeeded, &BytesNeeded, &NumServices, &ResumeHandle, 0) == 0)
{
HeapFree(GetProcessHeap(), 0, pServiceStatus);
CloseServiceHandle(ScHandle);
return;
}
}
else /* exit on failure */
{
CloseServiceHandle(ScHandle);
return;
}
}
if (NumServices)
{
if (!pServiceStatus)
{
CloseServiceHandle(ScHandle);
return;
}
for (Index = 0; Index < NumServices; Index++)
{
memset(&item, 0, sizeof(LV_ITEM));
item.mask = LVIF_TEXT;
item.iImage = 0;
item.pszText = pServiceStatus[Index].lpDisplayName;
item.iItem = ListView_GetItemCount(hServicesListCtrl);
item.lParam = 0;
item.iItem = ListView_InsertItem(hServicesListCtrl, &item);
if (pServiceStatus[Index].ServiceStatusProcess.dwCurrentState == SERVICE_RUNNING)
{
ListView_SetCheckState(hServicesListCtrl, item.iItem, TRUE);
}
BytesNeeded = 0;
hService = OpenService(ScHandle, pServiceStatus[Index].lpServiceName, SC_MANAGER_CONNECT);
if (hService != NULL)
{
/* check if service is required by the system*/
if (!QueryServiceConfig2(hService, SERVICE_CONFIG_FAILURE_ACTIONS, (LPBYTE)NULL, 0, &BytesNeeded))
{
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
pServiceFailureActions = HeapAlloc(GetProcessHeap(), 0, BytesNeeded);
if (pServiceFailureActions == NULL)
{
HeapFree(GetProcessHeap(), 0, pServiceStatus);
CloseServiceHandle(hService);
CloseServiceHandle(ScHandle);
return;
}
if (!QueryServiceConfig2(hService, SERVICE_CONFIG_FAILURE_ACTIONS, (LPBYTE)pServiceFailureActions, BytesNeeded, &BytesNeeded))
{
HeapFree(GetProcessHeap(), 0, pServiceFailureActions);
HeapFree(GetProcessHeap(), 0, pServiceStatus);
CloseServiceHandle(hService);
CloseServiceHandle(ScHandle);
return;
}
}
else /* exit on failure */
{
HeapFree(GetProcessHeap(), 0, pServiceStatus);
CloseServiceHandle(hService);
CloseServiceHandle(ScHandle);
return;
}
}
if (pServiceFailureActions != NULL)
{
if (pServiceFailureActions->cActions && pServiceFailureActions->lpsaActions[0].Type == SC_ACTION_REBOOT)
{
LoadString(hInst, IDS_SERVICES_YES, szStatus, 128);
item.pszText = szStatus;
item.iSubItem = 1;
SendMessage(hServicesListCtrl, LVM_SETITEMTEXT, item.iItem, (LPARAM) &item);
}
HeapFree(GetProcessHeap(), 0, pServiceFailureActions);
pServiceFailureActions = NULL;
}
/* get vendor of service binary */
BytesNeeded = 0;
if (!QueryServiceConfig(hService, NULL, 0, &BytesNeeded))
{
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
pServiceConfig = HeapAlloc(GetProcessHeap(), 0, BytesNeeded);
if (pServiceConfig == NULL)
{
HeapFree(GetProcessHeap(), 0, pServiceStatus);
CloseServiceHandle(hService);
CloseServiceHandle(ScHandle);
return;
}
if (!QueryServiceConfig(hService, pServiceConfig, BytesNeeded, &BytesNeeded))
{
HeapFree(GetProcessHeap(), 0, pServiceConfig);
HeapFree(GetProcessHeap(), 0, pServiceStatus);
CloseServiceHandle(hService);
CloseServiceHandle(ScHandle);
return;
}
}
else /* exit on failure */
{
HeapFree(GetProcessHeap(), 0, pServiceStatus);
CloseServiceHandle(hService);
CloseServiceHandle(ScHandle);
return;
}
}
memset(&FileName, 0, MAX_PATH);
if (_tcscspn(pServiceConfig->lpBinaryPathName, _T("\"")))
{
_tcsncpy(FileName, pServiceConfig->lpBinaryPathName, _tcscspn(pServiceConfig->lpBinaryPathName, _T(" ")) );
}
else
{
_tcscpy(FileName, pServiceConfig->lpBinaryPathName);
}
HeapFree(GetProcessHeap(), 0, pServiceConfig);
pServiceConfig = NULL;
dwLen = GetFileVersionInfoSize(FileName, &dwHandle);
if (dwLen)
{
lpData = HeapAlloc(GetProcessHeap(), 0, dwLen);
if (lpData == NULL)
{
HeapFree(GetProcessHeap(), 0, pServiceStatus);
CloseServiceHandle(hService);
CloseServiceHandle(ScHandle);
return;
}
if (!GetFileVersionInfo (FileName, dwHandle, dwLen, lpData))
{
HeapFree(GetProcessHeap(), 0, lpData);
HeapFree(GetProcessHeap(), 0, pServiceStatus);
CloseServiceHandle(hService);
CloseServiceHandle(ScHandle);
return;
}
if (VerQueryValue(lpData, _T("\\VarFileInfo\\Translation"), &pvData, (PUINT) &BufLen))
{
wCodePage = LOWORD(*(DWORD*) pvData);
wLangID = HIWORD(*(DWORD*) pvData);
wsprintf(szStrFileInfo, _T("StringFileInfo\\%04X%04X\\CompanyName"), wCodePage, wLangID);
}
if (VerQueryValue (lpData, szStrFileInfo, (void**) &lpBuffer, (PUINT) &BufLen))
{
item.pszText = lpBuffer;
item.iSubItem = 2;
SendMessage(hServicesListCtrl, LVM_SETITEMTEXT, item.iItem, (LPARAM) &item);
}
HeapFree(GetProcessHeap(), 0, lpData);
}
else
{
LoadString(hInst, IDS_SERVICES_UNKNOWN, szStatus, 128);
item.pszText = szStatus;
item.iSubItem = 2;
SendMessage(hServicesListCtrl, LVM_SETITEMTEXT, item.iItem, (LPARAM) &item);
}
CloseServiceHandle(hService);
}
LoadString(hInst, ((pServiceStatus[Index].ServiceStatusProcess.dwCurrentState == SERVICE_STOPPED) ? IDS_SERVICES_STATUS_STOPPED : IDS_SERVICES_STATUS_RUNNING), szStatus, 128);
item.pszText = szStatus;
item.iSubItem = 3;
SendMessage(hServicesListCtrl, LVM_SETITEMTEXT, item.iItem, (LPARAM) &item);
}
}
HeapFree(GetProcessHeap(), 0, pServiceStatus);
CloseServiceHandle(ScHandle);
}
}
int SERVICE_DISCOVERY(AGENT_REQUEST *request, AGENT_RESULT *result)
{
ENUM_SERVICE_STATUS_PROCESS *ssp = NULL;
QUERY_SERVICE_CONFIG *qsc = NULL;
SERVICE_DESCRIPTION *scd = NULL;
SC_HANDLE h_mgr;
DWORD sz = 0, szn, i, k, services, resume_handle = 0;
char *utf8;
struct zbx_json j;
if (NULL == (h_mgr = OpenSCManager(NULL, NULL, GENERIC_READ)))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot obtain system information."));
return SYSINFO_RET_FAIL;
}
zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);
while (0 != EnumServicesStatusEx(h_mgr, SC_ENUM_PROCESS_INFO, SERVICE_WIN32, SERVICE_STATE_ALL,
(LPBYTE)ssp, sz, &szn, &services, &resume_handle, NULL) || ERROR_MORE_DATA == GetLastError())
{
for (i = 0; i < services; i++)
{
SC_HANDLE h_srv;
DWORD current_state;
if (NULL == (h_srv = OpenService(h_mgr, ssp[i].lpServiceName, SERVICE_QUERY_CONFIG)))
continue;
QueryServiceConfig(h_srv, NULL, 0, &sz);
if (ERROR_INSUFFICIENT_BUFFER != GetLastError())
{
zabbix_log(LOG_LEVEL_DEBUG, "cannot obtain configuration of service \"%s\": %s",
ssp[i].lpServiceName, strerror_from_system(GetLastError()));
goto next;
}
qsc = (QUERY_SERVICE_CONFIG *)zbx_malloc(qsc, sz);
if (0 == QueryServiceConfig(h_srv, qsc, sz, &sz))
{
zabbix_log(LOG_LEVEL_DEBUG, "cannot obtain configuration of service \"%s\": %s",
ssp[i].lpServiceName, strerror_from_system(GetLastError()));
goto next;
}
QueryServiceConfig2(h_srv, SERVICE_CONFIG_DESCRIPTION, NULL, 0, &sz);
if (ERROR_INSUFFICIENT_BUFFER != GetLastError())
{
zabbix_log(LOG_LEVEL_DEBUG, "cannot obtain description of service \"%s\": %s",
ssp[i].lpServiceName, strerror_from_system(GetLastError()));
goto next;
}
scd = (SERVICE_DESCRIPTION *)zbx_malloc(scd, sz);
if (0 == QueryServiceConfig2(h_srv, SERVICE_CONFIG_DESCRIPTION, (LPBYTE)scd, sz, &sz))
{
zabbix_log(LOG_LEVEL_DEBUG, "cannot obtain description of service \"%s\": %s",
ssp[i].lpServiceName, strerror_from_system(GetLastError()));
goto next;
}
zbx_json_addobject(&j, NULL);
utf8 = zbx_unicode_to_utf8(ssp[i].lpServiceName);
zbx_json_addstring(&j, "{#SERVICE.NAME}", utf8, ZBX_JSON_TYPE_STRING);
zbx_free(utf8);
utf8 = zbx_unicode_to_utf8(ssp[i].lpDisplayName);
zbx_json_addstring(&j, "{#SERVICE.DISPLAYNAME}", utf8, ZBX_JSON_TYPE_STRING);
zbx_free(utf8);
if (NULL != scd->lpDescription)
{
utf8 = zbx_unicode_to_utf8(scd->lpDescription);
zbx_json_addstring(&j, "{#SERVICE.DESCRIPTION}", utf8, ZBX_JSON_TYPE_STRING);
zbx_free(utf8);
}
else
zbx_json_addstring(&j, "{#SERVICE.DESCRIPTION}", "", ZBX_JSON_TYPE_STRING);
current_state = ssp[i].ServiceStatusProcess.dwCurrentState;
for (k = 0; k < ARRSIZE(service_states) && current_state != service_states[k]; k++)
;
zbx_json_adduint64(&j, "{#SERVICE.STATE}", k);
zbx_json_addstring(&j, "{#SERVICE.STATENAME}", get_state_string(current_state),
ZBX_JSON_TYPE_STRING);
utf8 = zbx_unicode_to_utf8(qsc->lpBinaryPathName);
zbx_json_addstring(&j, "{#SERVICE.PATH}", utf8, ZBX_JSON_TYPE_STRING);
zbx_free(utf8);
utf8 = zbx_unicode_to_utf8(qsc->lpServiceStartName);
zbx_json_addstring(&j, "{#SERVICE.USER}", utf8, ZBX_JSON_TYPE_STRING);
zbx_free(utf8);
if (SERVICE_AUTO_START == qsc->dwStartType)
{
if (SUCCEED == check_delayed_start(h_srv))
{
zbx_json_adduint64(&j, "{#SERVICE.STARTUP}", 1);
zbx_json_addstring(&j, "{#SERVICE.STARTUPNAME}", "automatic delayed",
ZBX_JSON_TYPE_STRING);
}
else
{
zbx_json_adduint64(&j, "{#SERVICE.STARTUP}", 0);
zbx_json_addstring(&j, "{#SERVICE.STARTUPNAME}", "automatic",
ZBX_JSON_TYPE_STRING);
}
}
else
{
for (k = 2; k < ARRSIZE(start_types) && qsc->dwStartType != start_types[k]; k++)
;
zbx_json_adduint64(&j, "{#SERVICE.STARTUP}", k);
zbx_json_addstring(&j, "{#SERVICE.STARTUPNAME}", get_startup_string(qsc->dwStartType),
ZBX_JSON_TYPE_STRING);
}
zbx_json_close(&j);
next:
zbx_free(scd);
zbx_free(qsc);
CloseServiceHandle(h_srv);
}
if (0 == szn)
break;
if (NULL == ssp)
{
sz = szn;
ssp = (ENUM_SERVICE_STATUS_PROCESS *)zbx_malloc(ssp, sz);
}
}
zbx_free(ssp);
CloseServiceHandle(h_mgr);
zbx_json_close(&j);
SET_STR_RESULT(result, zbx_strdup(NULL, j.buffer));
zbx_json_free(&j);
return SYSINFO_RET_OK;
}
BOOL
GetServiceList(PMAIN_WND_INFO Info,
DWORD *NumServices)
{
SC_HANDLE ScHandle;
BOOL bRet = FALSE;
DWORD BytesNeeded = 0;
DWORD ResumeHandle = 0;
*NumServices = 0;
if (Info->pAllServices != NULL)
{
HeapFree(ProcessHeap,
0,
Info->pAllServices);
Info->pAllServices = NULL;
}
ScHandle = OpenSCManagerW(NULL,
NULL,
SC_MANAGER_ENUMERATE_SERVICE);
if (ScHandle != NULL)
{
if (!EnumServicesStatusEx(ScHandle,
SC_ENUM_PROCESS_INFO,
SERVICE_WIN32,
SERVICE_STATE_ALL,
NULL,
0,
&BytesNeeded,
NumServices,
&ResumeHandle,
0))
{
/* Call function again if required size was returned */
if (GetLastError() == ERROR_MORE_DATA)
{
/* reserve memory for service info array */
Info->pAllServices = (ENUM_SERVICE_STATUS_PROCESS *) HeapAlloc(ProcessHeap,
0,
BytesNeeded);
if (Info->pAllServices)
{
/* fill array with service info */
if (EnumServicesStatusEx(ScHandle,
SC_ENUM_PROCESS_INFO,
SERVICE_WIN32,
SERVICE_STATE_ALL,
(LPBYTE)Info->pAllServices,
BytesNeeded,
&BytesNeeded,
NumServices,
&ResumeHandle,
0))
{
bRet = TRUE;
}
}
}
}
}
if (ScHandle)
CloseServiceHandle(ScHandle);
if (!bRet && Info->pAllServices)
{
HeapFree(ProcessHeap,
0,
Info->pAllServices);
}
return bRet;
}
void CServices::GetServiceInfo()
{
SC_HANDLE sc = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
if(sc==NULL)
return;
SC_HANDLE hSCCervice;
DWORD ret=0;
DWORD size=0;
DWORD dwError=0;
LPENUM_SERVICE_STATUS_PROCESS st;
LPQUERY_SERVICE_CONFIG lpsc;
CServices::PSERVICEINFO pServiceInfo;
/*得到所需要的大小*/
if(!EnumServicesStatusEx(sc,SC_ENUM_PROCESS_INFO, SERVICE_WIN32,SERVICE_STATE_ALL, NULL,0,&size,&ret, NULL, NULL))
{
st = (LPENUM_SERVICE_STATUS_PROCESS)LocalAlloc(LPTR,(SIZE_T)size);
EnumServicesStatusEx(sc,SC_ENUM_PROCESS_INFO,SERVICE_WIN32,SERVICE_STATE_ALL, (LPBYTE)st,size,&size,&ret,NULL, NULL);
}
pServiceInfo = (CServices::PSERVICEINFO)LocalAlloc(LPTR,(SIZE_T)(ret * sizeof(SERVICEINFO)));
CServices::PSERVICEINFO pTemp = pServiceInfo;
/*得到每一个服务的有关信息*/
for (int i=0; i<ret; i++)
{
hSCCervice = OpenService(sc, st[i].lpServiceName, SERVICE_QUERY_CONFIG);
if(hSCCervice == NULL)
{
CloseServiceHandle(sc);
return;
}
/*得到服务信息所需大小*/
if(!QueryServiceConfig(hSCCervice, NULL, 0, &size))
{
dwError = GetLastError();
if(ERROR_INSUFFICIENT_BUFFER == dwError)
{
lpsc = (LPQUERY_SERVICE_CONFIG)LocalAlloc(LPTR,(SIZE_T)size);
QueryServiceConfig(hSCCervice, lpsc, size, &size);
}else{
goto cleanup;
}
}
pTemp->ServiceStatus = st[i];
/*所属组为exe文件路径中"－k "之后的字符*/
WCHAR *p = wcsstr(lpsc->lpBinaryPathName, TEXT("-k"));
/*没有则说明不属于任何组*/
if(NULL == p)
{
wcscpy(pTemp->OrderGroup, TEXT("N/A"));
}
else
{
wcscpy(pTemp->OrderGroup, p+3);
}
pTemp++;
}
RefreshSevice(pServiceInfo, ret);
cleanup:
CloseServiceHandle(sc);
CloseServiceHandle(hSCCervice);
}
/*
* supCreateSCMSnapshot
*
* Purpose:
*
* Collects SCM information for drivers description.
*
* Returned buffer must be freed with supFreeScmSnapshot after usage.
*
*/
PVOID supCreateSCMSnapshot(
PSIZE_T lpNumberOfEntries
)
{
BOOL cond = FALSE, bResult = FALSE;
SC_HANDLE schSCManager;
DWORD dwBytesNeeded, dwServicesReturned, dwSize, dwSlack;
PVOID Services = NULL;
if (lpNumberOfEntries) {
*lpNumberOfEntries = 0;
}
do {
schSCManager = OpenSCManager(NULL,
NULL,
SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE
);
if (schSCManager == NULL) {
break;
}
// query required memory size for snapshot
dwBytesNeeded = 0;
dwServicesReturned = 0;
dwSize = 0x1000;
Services = VirtualAlloc(NULL, dwSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (Services == NULL) {
break;
}
bResult = EnumServicesStatusEx(schSCManager, SC_ENUM_PROCESS_INFO, SERVICE_DRIVER,
SERVICE_STATE_ALL, Services, dwSize, &dwBytesNeeded, &dwServicesReturned, NULL, NULL);
if (bResult == FALSE) {
if (GetLastError() == ERROR_MORE_DATA) {
// allocate memory block with page aligned size
VirtualFree(Services, 0, MEM_RELEASE);
dwSize = dwBytesNeeded + sizeof(ENUM_SERVICE_STATUS_PROCESS);
dwSlack = dwSize % 0x1000;
if (dwSlack > 0) dwSize = dwSize + 0x1000 - dwSlack;
Services = VirtualAlloc(NULL, dwSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (Services == NULL) {
break;
}
if (!EnumServicesStatusEx(schSCManager, SC_ENUM_PROCESS_INFO, SERVICE_DRIVER,
SERVICE_STATE_ALL, Services, dwSize, &dwBytesNeeded, &dwServicesReturned, NULL, NULL))
{
VirtualFree(Services, 0, MEM_RELEASE);
Services = NULL;
break;
}
} //ERROR_MORE_DATA
} //bResult == FALSE;
// also return actual number of services
if (lpNumberOfEntries) {
*lpNumberOfEntries = dwServicesReturned;
}
CloseServiceHandle(schSCManager);
} while (cond);
return Services;
}
static BOOL
EnumServices(ENUM_SERVICE_STATUS_PROCESS **pServiceStatus,
DWORD ServiceType,
DWORD ServiceState)
{
SC_HANDLE hSCManager;
DWORD BufSize = 0;
DWORD BytesNeeded = 0;
DWORD ResumeHandle = 0;
DWORD NumServices = 0;
DWORD Ret;
hSCManager = OpenSCManager(NULL,
NULL,
SC_MANAGER_ENUMERATE_SERVICE);
if (hSCManager == NULL)
{
ReportLastError();
return FALSE;
}
Ret = EnumServicesStatusEx(hSCManager,
SC_ENUM_PROCESS_INFO,
ServiceType,
ServiceState,
(LPBYTE)*pServiceStatus,
BufSize,
&BytesNeeded,
&NumServices,
&ResumeHandle,
0);
if ((Ret == 0) && (GetLastError() == ERROR_MORE_DATA))
{
*pServiceStatus = (ENUM_SERVICE_STATUS_PROCESS *)
HeapAlloc(GetProcessHeap(),
0,
BytesNeeded);
if (*pServiceStatus != NULL)
{
if (EnumServicesStatusEx(hSCManager,
SC_ENUM_PROCESS_INFO,
ServiceType,
ServiceState,
(LPBYTE)*pServiceStatus,
BytesNeeded,
&BytesNeeded,
&NumServices,
&ResumeHandle,
0))
{
CloseServiceHandle(hSCManager);
return NumServices;
}
}
}
ReportLastError();
if (*pServiceStatus)
HeapFree(GetProcessHeap(), 0, *pServiceStatus);
CloseServiceHandle(hSCManager);
return NumServices;
}
/*
* Enumerate all services.
*/
PyObject *
psutil_winservice_enumerate(PyObject *self, PyObject *args) {
ENUM_SERVICE_STATUS_PROCESS *lpService = NULL;
BOOL ok;
SC_HANDLE sc = NULL;
DWORD bytesNeeded = 0;
DWORD srvCount;
DWORD resumeHandle = 0;
DWORD dwBytes = 0;
DWORD i;
PyObject *py_retlist = PyList_New(0);
PyObject *py_tuple = NULL;
PyObject *py_unicode_display_name = NULL;
if (py_retlist == NULL)
return NULL;
sc = OpenSCManager(NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE);
if (sc == NULL) {
PyErr_SetFromWindowsErr(0);
return NULL;
}
for (;;) {
ok = EnumServicesStatusEx(
sc,
SC_ENUM_PROCESS_INFO,
SERVICE_WIN32, // XXX - extend this to include drivers etc.?
SERVICE_STATE_ALL,
(LPBYTE)lpService,
dwBytes,
&bytesNeeded,
&srvCount,
&resumeHandle,
NULL);
if (ok || (GetLastError() != ERROR_MORE_DATA))
break;
if (lpService)
free(lpService);
dwBytes = bytesNeeded;
lpService = (ENUM_SERVICE_STATUS_PROCESS*)malloc(dwBytes);
}
for (i = 0; i < srvCount; i++) {
// Get unicode display name.
py_unicode_display_name = NULL;
py_unicode_display_name = PyUnicode_Decode(
lpService[i].lpDisplayName,
_tcslen(lpService[i].lpDisplayName),
Py_FileSystemDefaultEncoding,
"replace");
if (py_unicode_display_name == NULL)
goto error;
// Construct the result.
py_tuple = Py_BuildValue(
"(sO)",
lpService[i].lpServiceName, // name
py_unicode_display_name // display_name
);
if (py_tuple == NULL)
goto error;
if (PyList_Append(py_retlist, py_tuple))
goto error;
Py_DECREF(py_unicode_display_name);
Py_DECREF(py_tuple);
}
// Free resources.
CloseServiceHandle(sc);
free(lpService);
return py_retlist;
error:
Py_XDECREF(py_unicode_display_name);
Py_XDECREF(py_tuple);
Py_DECREF(py_retlist);
if (sc != NULL)
CloseServiceHandle(sc);
if (lpService != NULL)
free(lpService);
return NULL;
}
