if (lpDatabaseName == NULL)
lpDatabaseName = SERVICES_ACTIVE_DATABASEW;
- if (wcsicmp(lpDatabaseName,SERVICES_FAILED_DATABASEW)==0)
+ if (_wcsicmp(lpDatabaseName,SERVICES_FAILED_DATABASEW)==0)
{
- DPRINT1("Database %S, does not exist\n",lpDatabaseName);
+ DPRINT("Database %S, does not exist\n",lpDatabaseName);
return ERROR_DATABASE_DOES_NOT_EXIST;
}
- else if (wcsicmp(lpDatabaseName, SERVICES_ACTIVE_DATABASEW) != 0)
+ else if (_wcsicmp(lpDatabaseName, SERVICES_ACTIVE_DATABASEW) != 0)
{
- DPRINT1("Invalid Database name %S.\n",lpDatabaseName);
+ DPRINT("Invalid Database name %S.\n",lpDatabaseName);
return ERROR_INVALID_NAME;
}
Ptr = (MANAGER_HANDLE*) HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
- sizeof(MANAGER_HANDLE) + wcslen(lpDatabaseName) * sizeof(WCHAR));
+ sizeof(MANAGER_HANDLE) + (wcslen(lpDatabaseName) + 1) * sizeof(WCHAR));
if (Ptr == NULL)
return ERROR_NOT_ENOUGH_MEMORY;
NULL);
if (dwError != ERROR_SUCCESS)
{
- DPRINT1("ERROR! Unable to get number of services keys.\n");
+ DPRINT("ERROR! Unable to get number of services keys.\n");
return dwError;
}
/* Can be more than one Dependencies in the DependOnService string */
while (wcslen(lpszValueBuf + dwDependServiceStrPtr) > 0)
{
- if (wcsicmp(lpszValueBuf + dwDependServiceStrPtr, lpService->lpServiceName) == 0)
+ if (_wcsicmp(lpszValueBuf + dwDependServiceStrPtr, lpService->lpServiceName) == 0)
{
/* Get the current enumed service pointer */
lpCurrentService = ScmGetServiceEntryByName(lpszNameBuf);
if (!lpCurrentService)
{
/* This should never happen! */
- DPRINT1("This should not happen at this point, report to Developer\n");
+ DPRINT("This should not happen at this point, report to Developer\n");
return ERROR_NOT_FOUND;
}
/* Function 0 */
DWORD RCloseServiceHandle(
- handle_t BindingHandle,
LPSC_RPC_HANDLE hSCObject)
{
PMANAGER_HANDLE hManager;
+ PSERVICE_HANDLE hService;
+ PSERVICE lpService;
+ HKEY hServicesKey;
+ DWORD dwError;
+ DWORD pcbBytesNeeded = 0;
+ DWORD dwServicesReturned = 0;
DPRINT("RCloseServiceHandle() called\n");
return ERROR_INVALID_HANDLE;
hManager = (PMANAGER_HANDLE)*hSCObject;
+ hService = (PSERVICE_HANDLE)*hSCObject;
if (hManager->Handle.Tag == MANAGER_TAG)
{
DPRINT("Found manager handle\n");
hManager->Handle.RefCount--;
if (hManager->Handle.RefCount == 0)
{
- /* FIXME: add cleanup code */
+ /* FIXME: add handle cleanup code */
HeapFree(GetProcessHeap(), 0, hManager);
+ hManager = NULL;
}
DPRINT("RCloseServiceHandle() done\n");
return ERROR_SUCCESS;
}
- else if (hManager->Handle.Tag == SERVICE_TAG)
+ else if (hService->Handle.Tag == SERVICE_TAG)
{
DPRINT("Found service handle\n");
- hManager->Handle.RefCount--;
- if (hManager->Handle.RefCount == 0)
+ /* Get the pointer to the service record */
+ lpService = hService->ServiceEntry;
+
+ ASSERT(hService->Handle.RefCount > 0);
+
+ hService->Handle.RefCount--;
+ if (hService->Handle.RefCount == 0)
{
- /* FIXME: add cleanup code */
+ /* FIXME: add handle cleanup code */
- HeapFree(GetProcessHeap(), 0, hManager);
+ /* Free the handle */
+ HeapFree(GetProcessHeap(), 0, hService);
+ hService = NULL;
+ }
+
+ ASSERT(lpService->dwRefCount > 0);
+
+ lpService->dwRefCount--;
+ DPRINT("CloseServiceHandle - lpService->dwRefCount %u\n",
+ lpService->dwRefCount);
+
+ if (lpService->dwRefCount == 0)
+ {
+ /* If this service has been marked for deletion */
+ if (lpService->bDeleted)
+ {
+ /* Open the Services Reg key */
+ dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
+ L"System\\CurrentControlSet\\Services",
+ 0,
+ KEY_SET_VALUE | KEY_READ,
+ &hServicesKey);
+ if (dwError != ERROR_SUCCESS)
+ {
+ DPRINT("Failed to open services key\n");
+ return dwError;
+ }
+
+ /* Call the internal function with NULL, just to get bytes we need */
+ Int_EnumDependentServicesW(hServicesKey,
+ lpService,
+ SERVICE_ACTIVE,
+ NULL,
+ &pcbBytesNeeded,
+ &dwServicesReturned);
+
+ /* if pcbBytesNeeded returned a value then there are services running that are dependent on this service*/
+ if (pcbBytesNeeded)
+ {
+ DPRINT("Deletion failed due to running dependencies.\n");
+ RegCloseKey(hServicesKey);
+ return ERROR_SUCCESS;
+ }
+
+ /* There are no references and no runnning dependencies,
+ it is now safe to delete the service */
+
+ /* Delete the Service Key */
+ dwError = RegDeleteKeyW(hServicesKey,
+ lpService->lpServiceName);
+
+ RegCloseKey(hServicesKey);
+
+ if (dwError != ERROR_SUCCESS)
+ {
+ DPRINT("Failed to Delete the Service Registry key\n");
+ return dwError;
+ }
+
+ /* Delete the Service */
+ ScmDeleteServiceRecord(lpService);
+ }
}
DPRINT("RCloseServiceHandle() done\n");
return ERROR_SUCCESS;
}
- DPRINT1("Invalid handle tag (Tag %lx)\n", hManager->Handle.Tag);
+ DPRINT("Invalid handle tag (Tag %lx)\n", hManager->Handle.Tag);
return ERROR_INVALID_HANDLE;
}
/* Function 1 */
DWORD RControlService(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
DWORD dwControl,
LPSERVICE_STATUS lpServiceStatus)
PSERVICE lpService;
ACCESS_MASK DesiredAccess;
DWORD dwError = ERROR_SUCCESS;
+ DWORD pcbBytesNeeded = 0;
+ DWORD dwServicesReturned = 0;
+ HKEY hServicesKey = NULL;
DPRINT("RControlService() called\n");
hSvc = (PSERVICE_HANDLE)hService;
if (!hSvc || hSvc->Handle.Tag != SERVICE_TAG)
{
- DPRINT1("Invalid handle tag!\n");
+ DPRINT("Invalid handle tag!\n");
+ return ERROR_INVALID_HANDLE;
+ }
+
+ /* Check the service entry point */
+ lpService = hSvc->ServiceEntry;
+ if (lpService == NULL)
+ {
+ DPRINT("lpService == NULL!\n");
return ERROR_INVALID_HANDLE;
}
DesiredAccess))
return ERROR_ACCESS_DENIED;
- /* Check the service entry point */
- lpService = hSvc->ServiceEntry;
- if (lpService == NULL)
+ if (dwControl == SERVICE_CONTROL_STOP)
{
- DPRINT1("lpService == NULL!\n");
- return ERROR_INVALID_HANDLE;
+ /* Check if the service has dependencies running as windows
+ doesn't stop a service that does */
+
+ /* Open the Services Reg key */
+ dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
+ L"System\\CurrentControlSet\\Services",
+ 0,
+ KEY_READ,
+ &hServicesKey);
+ if (dwError != ERROR_SUCCESS)
+ {
+ DPRINT("Failed to open services key\n");
+ return dwError;
+ }
+
+ /* Call the internal function with NULL, just to get bytes we need */
+ Int_EnumDependentServicesW(hServicesKey,
+ lpService,
+ SERVICE_ACTIVE,
+ NULL,
+ &pcbBytesNeeded,
+ &dwServicesReturned);
+
+ RegCloseKey(hServicesKey);
+
+ /* If pcbBytesNeeded is not zero then there are services running that
+ are dependent on this service */
+ if (pcbBytesNeeded != 0)
+ {
+ DPRINT("Service has running dependencies. Failed to stop service.\n");
+ return ERROR_DEPENDENT_SERVICES_RUNNING;
+ }
}
if (lpService->Status.dwServiceType & SERVICE_DRIVER)
lpServiceStatus);
}
+ if ((dwError == ERROR_SUCCESS) && (pcbBytesNeeded))
+ dwError = ERROR_DEPENDENT_SERVICES_RUNNING;
+
+ if (dwError == ERROR_SUCCESS &&
+ dwControl == SERVICE_CONTROL_STOP &&
+ lpServiceStatus->dwCurrentState == SERVICE_STOPPED)
+ {
+ lpService->ProcessId = 0; /* FIXME */
+ lpService->ThreadId = 0;
+ }
+
/* Return service status information */
RtlCopyMemory(lpServiceStatus,
&lpService->Status,
/* Function 2 */
DWORD RDeleteService(
- handle_t BindingHandle,
SC_RPC_HANDLE hService)
{
PSERVICE_HANDLE hSvc;
lpService = hSvc->ServiceEntry;
if (lpService == NULL)
{
- DPRINT1("lpService == NULL!\n");
+ DPRINT("lpService == NULL!\n");
return ERROR_INVALID_HANDLE;
}
if (lpService->bDeleted)
{
- DPRINT1("The service has already been marked for delete!\n");
+ DPRINT("The service has already been marked for delete!\n");
return ERROR_SERVICE_MARKED_FOR_DELETE;
}
/* Function 3 */
DWORD RLockServiceDatabase(
- handle_t BindingHandle,
SC_RPC_HANDLE hSCManager,
LPSC_RPC_LOCK lpLock)
{
// return ScmLockDatabase(0, hMgr->0xC, hLock);
/* FIXME: Lock the database */
- *lpLock = (void *)0x12345678; /* Dummy! */
+ *lpLock = (SC_RPC_LOCK)0x12345678; /* Dummy! */
return ERROR_SUCCESS;
}
/* Function 4 */
DWORD RQueryServiceObjectSecurity(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
SECURITY_INFORMATION dwSecurityInformation,
LPBYTE lpSecurityDescriptor,
DWORD cbBufSize,
LPBOUNDED_DWORD_256K pcbBytesNeeded)
{
-#if 0
PSERVICE_HANDLE hSvc;
PSERVICE lpService;
ULONG DesiredAccess = 0;
DWORD dwBytesNeeded;
DWORD dwError;
+
+ SECURITY_DESCRIPTOR ObjectDescriptor;
+
DPRINT("RQueryServiceObjectSecurity() called\n");
hSvc = (PSERVICE_HANDLE)hService;
if (!hSvc || hSvc->Handle.Tag != SERVICE_TAG)
{
- DPRINT1("Invalid handle tag!\n");
+ DPRINT("Invalid handle tag!\n");
return ERROR_INVALID_HANDLE;
}
if (!RtlAreAllAccessesGranted(hSvc->Handle.DesiredAccess,
DesiredAccess))
{
- DPRINT1("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
+ DPRINT("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
lpService = hSvc->ServiceEntry;
if (lpService == NULL)
{
- DPRINT1("lpService == NULL!\n");
+ DPRINT("lpService == NULL!\n");
return ERROR_INVALID_HANDLE;
}
/* FIXME: Lock the service list */
- Status = RtlQuerySecurityObject(lpService->lpSecurityDescriptor,
+ /* hack */
+ Status = RtlCreateSecurityDescriptor(&ObjectDescriptor, SECURITY_DESCRIPTOR_REVISION);
+
+ Status = RtlQuerySecurityObject(&ObjectDescriptor /* lpService->lpSecurityDescriptor */,
dwSecurityInformation,
(PSECURITY_DESCRIPTOR)lpSecurityDescriptor,
- dwSecuityDescriptorSize,
+ cbBufSize,
&dwBytesNeeded);
/* FIXME: Unlock the service list */
}
return dwError;
-#endif
- UNIMPLEMENTED;
- return ERROR_CALL_NOT_IMPLEMENTED;
}
/* Function 5 */
DWORD RSetServiceObjectSecurity(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
DWORD dwSecurityInformation,
LPBYTE lpSecurityDescriptor,
PSERVICE_HANDLE hSvc;
PSERVICE lpService;
ULONG DesiredAccess = 0;
- HANDLE hToken = NULL;
+ /* HANDLE hToken = NULL; */
HKEY hServiceKey;
- NTSTATUS Status;
+ /* NTSTATUS Status; */
DWORD dwError;
- DPRINT1("RSetServiceObjectSecurity() called\n");
+ DPRINT("RSetServiceObjectSecurity() called\n");
hSvc = (PSERVICE_HANDLE)hService;
if (!hSvc || hSvc->Handle.Tag != SERVICE_TAG)
{
- DPRINT1("Invalid handle tag!\n");
+ DPRINT("Invalid handle tag!\n");
return ERROR_INVALID_HANDLE;
}
DesiredAccess |= WRITE_OWNER;
if ((dwSecurityInformation & OWNER_SECURITY_INFORMATION) &&
- (((PSECURITY_DESCRIPTOR)lpSecurityDescriptor)->Owner == NULL))
+ (((PISECURITY_DESCRIPTOR)lpSecurityDescriptor)->Owner == NULL))
return ERROR_INVALID_PARAMETER;
if ((dwSecurityInformation & GROUP_SECURITY_INFORMATION) &&
- (((PSECURITY_DESCRIPTOR)lpSecurityDescriptor)->Group == NULL))
+ (((PISECURITY_DESCRIPTOR)lpSecurityDescriptor)->Group == NULL))
return ERROR_INVALID_PARAMETER;
if (!RtlAreAllAccessesGranted(hSvc->Handle.DesiredAccess,
DesiredAccess))
{
- DPRINT1("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
+ DPRINT("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
lpService = hSvc->ServiceEntry;
if (lpService == NULL)
{
- DPRINT1("lpService == NULL!\n");
+ DPRINT("lpService == NULL!\n");
return ERROR_INVALID_HANDLE;
}
if (lpService->bDeleted)
return ERROR_SERVICE_MARKED_FOR_DELETE;
+#if 0
RpcImpersonateClient(NULL);
Status = NtOpenThreadToken(NtCurrentThread(),
TRUE,
&hToken);
if (!NT_SUCCESS(Status))
- return RtlNtStatusToDosError(Status);
+ return RtlNtStatusToDosError(Status);
RpcRevertToSelf();
/* FIXME: Lock service database */
-#if 0
Status = RtlSetSecurityObject(dwSecurityInformation,
(PSECURITY_DESCRIPTOR)lpSecurityDescriptor,
&lpService->lpSecurityDescriptor,
Done:
+#if 0
if (hToken != NULL)
NtClose(hToken);
+#endif
/* FIXME: Unlock service database */
/* Function 6 */
DWORD RQueryServiceStatus(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
LPSERVICE_STATUS lpServiceStatus)
{
hSvc = (PSERVICE_HANDLE)hService;
if (!hSvc || hSvc->Handle.Tag != SERVICE_TAG)
{
- DPRINT1("Invalid handle tag!\n");
+ DPRINT("Invalid handle tag!\n");
return ERROR_INVALID_HANDLE;
}
if (!RtlAreAllAccessesGranted(hSvc->Handle.DesiredAccess,
SERVICE_QUERY_STATUS))
{
- DPRINT1("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
+ DPRINT("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
lpService = hSvc->ServiceEntry;
if (lpService == NULL)
{
- DPRINT1("lpService == NULL!\n");
+ DPRINT("lpService == NULL!\n");
return ERROR_INVALID_HANDLE;
}
}
+static BOOL
+ScmIsValidServiceState(DWORD dwCurrentState)
+{
+ switch (dwCurrentState)
+ {
+ case SERVICE_STOPPED:
+ case SERVICE_START_PENDING:
+ case SERVICE_STOP_PENDING:
+ case SERVICE_RUNNING:
+ case SERVICE_CONTINUE_PENDING:
+ case SERVICE_PAUSE_PENDING:
+ case SERVICE_PAUSED:
+ return TRUE;
+
+ default:
+ return FALSE;
+ }
+}
+
+
/* Function 7 */
DWORD RSetServiceStatus(
- handle_t BindingHandle,
- SC_RPC_HANDLE hServiceStatus,
+ RPC_SERVICE_STATUS_HANDLE hServiceStatus,
LPSERVICE_STATUS lpServiceStatus)
{
PSERVICE lpService;
DPRINT("RSetServiceStatus() called\n");
+ DPRINT("hServiceStatus = %p\n", hServiceStatus);
+ DPRINT("dwServiceType = %lu\n", lpServiceStatus->dwServiceType);
+ DPRINT("dwCurrentState = %lu\n", lpServiceStatus->dwCurrentState);
+ DPRINT("dwControlsAccepted = %lu\n", lpServiceStatus->dwControlsAccepted);
+ DPRINT("dwWin32ExitCode = %lu\n", lpServiceStatus->dwWin32ExitCode);
+ DPRINT("dwServiceSpecificExitCode = %lu\n", lpServiceStatus->dwServiceSpecificExitCode);
+ DPRINT("dwCheckPoint = %lu\n", lpServiceStatus->dwCheckPoint);
+ DPRINT("dwWaitHint = %lu\n", lpServiceStatus->dwWaitHint);
+
+ if (hServiceStatus == 0)
+ {
+ DPRINT("hServiceStatus == NULL!\n");
+ return ERROR_INVALID_HANDLE;
+ }
- if (ScmShutdown)
- return ERROR_SHUTDOWN_IN_PROGRESS;
-
- lpService = ScmGetServiceEntryByClientHandle((ULONG)hServiceStatus);
+ lpService = ScmGetServiceEntryByClientHandle((HANDLE)hServiceStatus);
if (lpService == NULL)
{
- DPRINT1("lpService == NULL!\n");
+ DPRINT("lpService == NULL!\n");
return ERROR_INVALID_HANDLE;
}
+ /* Check current state */
+ if (!ScmIsValidServiceState(lpServiceStatus->dwCurrentState))
+ {
+ DPRINT("Invalid service state!\n");
+ return ERROR_INVALID_DATA;
+ }
+
+ /* Check service type */
+ if (!(lpServiceStatus->dwServiceType & SERVICE_WIN32) &&
+ (lpServiceStatus->dwServiceType & SERVICE_DRIVER))
+ {
+ DPRINT("Invalid service type!\n");
+ return ERROR_INVALID_DATA;
+ }
+
+ /* Check accepted controls */
+ if (lpServiceStatus->dwControlsAccepted & ~0xFF)
+ {
+ DPRINT("Invalid controls accepted!\n");
+ return ERROR_INVALID_DATA;
+ }
+
+
RtlCopyMemory(&lpService->Status,
lpServiceStatus,
sizeof(SERVICE_STATUS));
/* Function 8 */
DWORD RUnlockServiceDatabase(
- handle_t BindingHandle,
LPSC_RPC_LOCK Lock)
{
UNIMPLEMENTED;
/* Function 9 */
DWORD RNotifyBootConfigStatus(
- handle_t BindingHandle,
SVCCTL_HANDLEW lpMachineName,
DWORD BootAcceptable)
{
/* Function 10 */
-DWORD RSetServiceBitsW(
- handle_t BindingHandle,
- SC_RPC_HANDLE hServiceStatus,
+DWORD RI_ScSetServiceBitsW(
+ RPC_SERVICE_STATUS_HANDLE hServiceStatus,
DWORD dwServiceBits,
int bSetBitsOn,
int bUpdateImmediately,
/* Function 11 */
DWORD RChangeServiceConfigW(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
DWORD dwServiceType,
DWORD dwStartType,
hSvc = (PSERVICE_HANDLE)hService;
if (!hSvc || hSvc->Handle.Tag != SERVICE_TAG)
{
- DPRINT1("Invalid handle tag!\n");
+ DPRINT("Invalid handle tag!\n");
return ERROR_INVALID_HANDLE;
}
if (!RtlAreAllAccessesGranted(hSvc->Handle.DesiredAccess,
SERVICE_CHANGE_CONFIG))
{
- DPRINT1("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
+ DPRINT("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
lpService = hSvc->ServiceEntry;
if (lpService == NULL)
{
- DPRINT1("lpService == NULL!\n");
+ DPRINT("lpService == NULL!\n");
return ERROR_INVALID_HANDLE;
}
if (lpService->bDeleted)
{
/* FIXME: Unlock database */
- DPRINT1("The service has already been marked for delete!\n");
+ DPRINT("The service has already been marked for delete!\n");
return ERROR_SERVICE_MARKED_FOR_DELETE;
}
(wcslen(lpLoadOrderGroup) + 1) * sizeof(WCHAR));
if (dwError != ERROR_SUCCESS)
goto done;
- /* FIXME: update lpService->lpServiceGroup */
+
+ dwError = ScmSetServiceGroup(lpService,
+ lpLoadOrderGroup);
+ if (dwError != ERROR_SUCCESS)
+ goto done;
}
if (lpdwTagId != NULL)
/* First check, if it's already good */
if (ServiceNameLen > 12 &&
- !wcsnicmp(L"\\SystemRoot\\", CanonName, 12))
+ !_wcsnicmp(L"\\SystemRoot\\", CanonName, 12))
{
*RelativeName = LocalAlloc(LMEM_ZEROINIT, ServiceNameLen * sizeof(WCHAR) + sizeof(WCHAR));
if (*RelativeName == NULL)
{
- DPRINT1("Error allocating memory for boot driver name!\n");
+ DPRINT("Error allocating memory for boot driver name!\n");
return ERROR_NOT_ENOUGH_MEMORY;
}
/* Copy it */
wcscpy(*RelativeName, CanonName);
- DPRINT1("Bootdriver name %S\n", *RelativeName);
+ DPRINT("Bootdriver name %S\n", *RelativeName);
return ERROR_SUCCESS;
}
/* If it has %SystemRoot% prefix, substitute it to \System*/
if (ServiceNameLen > 13 &&
- !wcsnicmp(L"%SystemRoot%\\", CanonName, 13))
+ !_wcsnicmp(L"%SystemRoot%\\", CanonName, 13))
{
/* There is no +sizeof(wchar_t) because the name is less by 1 wchar */
*RelativeName = LocalAlloc(LMEM_ZEROINIT, ServiceNameLen * sizeof(WCHAR));
if (*RelativeName == NULL)
{
- DPRINT1("Error allocating memory for boot driver name!\n");
+ DPRINT("Error allocating memory for boot driver name!\n");
return ERROR_NOT_ENOUGH_MEMORY;
}
wcscpy(*RelativeName, L"\\SystemRoot\\");
wcscat(*RelativeName, CanonName + 13);
- DPRINT1("Bootdriver name %S\n", *RelativeName);
+ DPRINT("Bootdriver name %S\n", *RelativeName);
return ERROR_SUCCESS;
}
if (BufferSize <= 1)
{
- DPRINT1("Error during a call to ExpandEnvironmentStringsW()\n");
+ DPRINT("Error during a call to ExpandEnvironmentStringsW()\n");
return ERROR_INVALID_ENVIRONMENT;
}
Expanded = LocalAlloc(LMEM_ZEROINIT, BufferSize * sizeof(WCHAR) + sizeof(WCHAR));
if (!Expanded)
{
- DPRINT1("Error allocating memory for boot driver name!\n");
+ DPRINT("Error allocating memory for boot driver name!\n");
return ERROR_NOT_ENOUGH_MEMORY;
}
if (ExpandEnvironmentStringsW(L"%SystemRoot%\\", Expanded, BufferSize) >
BufferSize)
{
- DPRINT1("Error during a call to ExpandEnvironmentStringsW()\n");
+ DPRINT("Error during a call to ExpandEnvironmentStringsW()\n");
LocalFree(Expanded);
return ERROR_NOT_ENOUGH_MEMORY;
}
/* Convert to NY-style path */
if (!RtlDosPathNameToNtPathName_U(Expanded, &NtPathName, NULL, NULL))
{
- DPRINT1("Error during a call to RtlDosPathNameToNtPathName_U()\n");
+ DPRINT("Error during a call to RtlDosPathNameToNtPathName_U()\n");
return ERROR_INVALID_ENVIRONMENT;
}
Expanded = LocalAlloc(LMEM_ZEROINIT, NtPathName.Length + sizeof(WCHAR));
if (!Expanded)
{
- DPRINT1("Error allocating memory for boot driver name!\n");
+ DPRINT("Error allocating memory for boot driver name!\n");
return ERROR_NOT_ENOUGH_MEMORY;
}
Expanded[ExpandedLen] = 0;
if (ServiceNameLen > ExpandedLen &&
- !wcsnicmp(Expanded, CanonName, ExpandedLen))
+ !_wcsnicmp(Expanded, CanonName, ExpandedLen))
{
/* Only \SystemRoot\ is missing */
*RelativeName = LocalAlloc(LMEM_ZEROINIT,
(ServiceNameLen - ExpandedLen) * sizeof(WCHAR) + 13*sizeof(WCHAR));
if (*RelativeName == NULL)
{
- DPRINT1("Error allocating memory for boot driver name!\n");
+ DPRINT("Error allocating memory for boot driver name!\n");
LocalFree(Expanded);
return ERROR_NOT_ENOUGH_MEMORY;
}
/* Check if required buffer size is sane */
if (BufferSize > 0xFFFD)
{
- DPRINT1("Too large buffer required\n");
+ DPRINT("Too large buffer required\n");
*RelativeName = 0;
if (SymbolicLinkHandle) NtClose(SymbolicLinkHandle);
LinkTarget.Buffer = LocalAlloc(LMEM_ZEROINIT, BufferSize + sizeof(WCHAR));
if (!LinkTarget.Buffer)
{
- DPRINT1("Unable to alloc buffer\n");
+ DPRINT("Unable to alloc buffer\n");
if (SymbolicLinkHandle) NtClose(SymbolicLinkHandle);
LocalFree(Expanded);
return ERROR_NOT_ENOUGH_MEMORY;
ExpandedLen = LinkTarget.Length / sizeof(WCHAR);
if ((ServiceNameLen > ExpandedLen) &&
- !wcsnicmp(LinkTarget.Buffer, CanonName, ExpandedLen))
+ !_wcsnicmp(LinkTarget.Buffer, CanonName, ExpandedLen))
{
*RelativeName = LocalAlloc(LMEM_ZEROINIT,
(ServiceNameLen - ExpandedLen) * sizeof(WCHAR) + 13*sizeof(WCHAR));
if (*RelativeName == NULL)
{
- DPRINT1("Unable to alloc buffer\n");
+ DPRINT("Unable to alloc buffer\n");
if (SymbolicLinkHandle) NtClose(SymbolicLinkHandle);
LocalFree(Expanded);
RtlFreeUnicodeString(&NtPathName);
}
else
{
- DPRINT1("Error, Status = %08X\n", Status);
+ DPRINT("Error, Status = %08X\n", Status);
if (SymbolicLinkHandle) NtClose(SymbolicLinkHandle);
LocalFree(Expanded);
RtlFreeUnicodeString(&NtPathName);
}
else
{
- DPRINT1("Error, Status = %08X\n", Status);
+ DPRINT("Error, Status = %08X\n", Status);
if (SymbolicLinkHandle) NtClose(SymbolicLinkHandle);
LocalFree(Expanded);
RtlFreeUnicodeString(&NtPathName);
}
else
{
- DPRINT1("Error, Status = %08X\n", Status);
+ DPRINT("Error, Status = %08X\n", Status);
LocalFree(Expanded);
return ERROR_INVALID_PARAMETER;
}
DWORD
ScmCanonDriverImagePath(DWORD dwStartType,
- wchar_t *lpServiceName,
+ const wchar_t *lpServiceName,
wchar_t **lpCanonName)
{
DWORD ServiceNameLen, Result;
UNICODE_STRING NtServiceName;
WCHAR *RelativeName;
- WCHAR *SourceName = lpServiceName;
+ const WCHAR *SourceName = lpServiceName;
/* Calculate the length of the service's name */
ServiceNameLen = wcslen(lpServiceName);
/* 12 is wcslen(L"\\SystemRoot\\") */
if (ServiceNameLen > 12 &&
- !wcsnicmp(L"\\SystemRoot\\", lpServiceName, 12))
+ !_wcsnicmp(L"\\SystemRoot\\", lpServiceName, 12))
{
/* SystemRoot prefix is already included */
if (*lpCanonName == NULL)
{
- DPRINT1("Error allocating memory for canonized service name!\n");
+ DPRINT("Error allocating memory for canonized service name!\n");
return ERROR_NOT_ENOUGH_MEMORY;
}
/* Check if it has %SystemRoot% (len=13) */
if (ServiceNameLen > 13 &&
- !wcsnicmp(L"%%SystemRoot%%\\", lpServiceName, 13))
+ !_wcsnicmp(L"%%SystemRoot%%\\", lpServiceName, 13))
{
/* Substitute %SystemRoot% with \\SystemRoot\\ */
*lpCanonName = LocalAlloc(LMEM_ZEROINIT, ServiceNameLen * sizeof(WCHAR) + sizeof(WCHAR));
if (*lpCanonName == NULL)
{
- DPRINT1("Error allocating memory for canonized service name!\n");
+ DPRINT("Error allocating memory for canonized service name!\n");
return ERROR_NOT_ENOUGH_MEMORY;
}
if (*lpCanonName == NULL)
{
- DPRINT1("Error allocating memory for canonized service name!\n");
+ DPRINT("Error allocating memory for canonized service name!\n");
return ERROR_NOT_ENOUGH_MEMORY;
}
/* It seems to be a DOS path, convert it */
if (!RtlDosPathNameToNtPathName_U(lpServiceName, &NtServiceName, NULL, NULL))
{
- DPRINT1("RtlDosPathNameToNtPathName_U() failed!\n");
+ DPRINT("RtlDosPathNameToNtPathName_U() failed!\n");
return ERROR_INVALID_PARAMETER;
}
if (*lpCanonName == NULL)
{
- DPRINT1("Error allocating memory for canonized service name!\n");
+ DPRINT("Error allocating memory for canonized service name!\n");
RtlFreeUnicodeString(&NtServiceName);
return ERROR_NOT_ENOUGH_MEMORY;
}
{
/* There is a problem, free name and return */
LocalFree(*lpCanonName);
- DPRINT1("Error converting named!\n");
+ DPRINT("Error converting named!\n");
return Result;
}
/* Function 12 */
DWORD RCreateServiceW(
- handle_t BindingHandle,
SC_RPC_HANDLE hSCManager,
- LPWSTR lpServiceName,
- LPWSTR lpDisplayName,
+ LPCWSTR lpServiceName,
+ LPCWSTR lpDisplayName,
DWORD dwDesiredAccess,
DWORD dwServiceType,
DWORD dwStartType,
DWORD dwErrorControl,
- LPWSTR lpBinaryPathName,
- LPWSTR lpLoadOrderGroup,
+ LPCWSTR lpBinaryPathName,
+ LPCWSTR lpLoadOrderGroup,
LPDWORD lpdwTagId,
LPBYTE lpDependencies,
DWORD dwDependSize,
- LPWSTR lpServiceStartName,
+ LPCWSTR lpServiceStartName,
LPBYTE lpPassword,
DWORD dwPwSize,
LPSC_RPC_HANDLE lpServiceHandle)
SC_HANDLE hServiceHandle = NULL;
LPWSTR lpImagePath = NULL;
HKEY hServiceKey = NULL;
+ LPWSTR lpObjectName;
DPRINT("RCreateServiceW() called\n");
DPRINT("lpServiceName = %S\n", lpServiceName);
hManager = (PMANAGER_HANDLE)hSCManager;
if (!hManager || hManager->Handle.Tag != MANAGER_TAG)
{
- DPRINT1("Invalid manager handle!\n");
+ DPRINT("Invalid manager handle!\n");
return ERROR_INVALID_HANDLE;
}
if (!RtlAreAllAccessesGranted(hManager->Handle.DesiredAccess,
SC_MANAGER_CREATE_SERVICE))
{
- DPRINT1("Insufficient access rights! 0x%lx\n",
- hManager->Handle.DesiredAccess);
+ DPRINT("Insufficient access rights! 0x%lx\n",
+ hManager->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
/* Fill the display name */
if (lpDisplayName != NULL &&
*lpDisplayName != 0 &&
- wcsicmp(lpService->lpDisplayName, lpDisplayName) != 0)
+ _wcsicmp(lpService->lpDisplayName, lpDisplayName) != 0)
{
lpService->lpDisplayName = (WCHAR*) HeapAlloc(GetProcessHeap(), 0,
(wcslen(lpDisplayName) + 1) * sizeof(WCHAR));
goto done;
}
- /* If a non driver and NULL for lpServiceName, write ObjectName as LocalSystem */
- if ((dwServiceType & SERVICE_WIN32) && (!lpServiceName))
+ /* Write service start name */
+ if (dwServiceType & SERVICE_WIN32)
{
+ lpObjectName = (lpServiceStartName != NULL) ? (LPWSTR)lpServiceStartName : L"LocalSystem";
dwError = RegSetValueExW(hServiceKey,
L"ObjectName",
0,
REG_SZ,
- (LPBYTE)L"LocalSystem",
- 24);
+ (LPBYTE)lpObjectName,
+ (wcslen(lpObjectName) + 1) * sizeof(WCHAR));
if (dwError != ERROR_SUCCESS)
goto done;
}
if (dwError != ERROR_SUCCESS)
goto done;
+ lpService->dwRefCount = 1;
+ DPRINT("CreateService - lpService->dwRefCount %u\n", lpService->dwRefCount);
+
done:;
if (hServiceKey != NULL)
RegCloseKey(hServiceKey);
if (dwError == ERROR_SUCCESS)
{
DPRINT("hService %p\n", hServiceHandle);
- *lpServiceHandle = (unsigned long)hServiceHandle; /* FIXME: 64 bit portability */
+ *lpServiceHandle = (SC_RPC_HANDLE)hServiceHandle;
if (lpdwTagId != NULL)
*lpdwTagId = lpService->dwTag;
/* Function 13 */
DWORD REnumDependentServicesW(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
DWORD dwServiceState,
LPBYTE lpServices,
if (!RtlAreAllAccessesGranted(hSvc->Handle.DesiredAccess,
SC_MANAGER_ENUMERATE_SERVICE))
{
- DPRINT1("Insufficient access rights! 0x%lx\n",
- hSvc->Handle.DesiredAccess);
+ DPRINT("Insufficient access rights! 0x%lx\n",
+ hSvc->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
(dwServicesReturned + 1) * sizeof(PSERVICE));
if (!lpServicesArray)
{
- DPRINT1("Could not allocate a buffer!!\n");
+ DPRINT("Could not allocate a buffer!!\n");
dwError = ERROR_NOT_ENOUGH_MEMORY;
goto Done;
}
/* Function 14 */
DWORD REnumServicesStatusW(
- handle_t BindingHandle,
SC_RPC_HANDLE hSCManager,
DWORD dwServiceType,
DWORD dwServiceState,
DWORD dwRequiredSize;
DWORD dwServiceCount;
DWORD dwSize;
- DWORD dwLastResumeCount;
+ DWORD dwLastResumeCount = 0;
LPENUM_SERVICE_STATUSW lpStatusPtr;
LPWSTR lpStringPtr;
hManager = (PMANAGER_HANDLE)hSCManager;
if (!hManager || hManager->Handle.Tag != MANAGER_TAG)
{
- DPRINT1("Invalid manager handle!\n");
+ DPRINT("Invalid manager handle!\n");
return ERROR_INVALID_HANDLE;
}
+ *pcbBytesNeeded = 0;
+ *lpServicesReturned = 0;
+
+ if ((dwServiceType!=SERVICE_DRIVER) && (dwServiceType!=SERVICE_WIN32))
+ {
+ DPRINT("Not a valid Service Type!\n");
+ return ERROR_INVALID_PARAMETER;
+ }
+
+ if ((dwServiceState<SERVICE_ACTIVE) || (dwServiceState>SERVICE_STATE_ALL))
+ {
+ DPRINT("Not a valid Service State!\n");
+ return ERROR_INVALID_PARAMETER;
+ }
+
/* Check access rights */
if (!RtlAreAllAccessesGranted(hManager->Handle.DesiredAccess,
SC_MANAGER_ENUMERATE_SERVICE))
{
- DPRINT1("Insufficient access rights! 0x%lx\n",
+ DPRINT("Insufficient access rights! 0x%lx\n",
hManager->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
- *pcbBytesNeeded = 0;
- *lpServicesReturned = 0;
-
- dwLastResumeCount = *lpResumeHandle;
+ if (lpResumeHandle)
+ dwLastResumeCount = *lpResumeHandle;
/* FIXME: Lock the service list shared */
DPRINT("*pcbBytesNeeded: %lu\n", dwRequiredSize);
- *lpResumeHandle = dwLastResumeCount;
+ if (lpResumeHandle)
+ *lpResumeHandle = dwLastResumeCount;
+
*lpServicesReturned = dwServiceCount;
*pcbBytesNeeded = dwRequiredSize;
dwRequiredSize += dwSize;
}
+ if (dwError == 0)
+ {
+ *pcbBytesNeeded = 0;
+ if (lpResumeHandle) *lpResumeHandle = 0;
+ }
+
Done:;
/* FIXME: Unlock the service list */
/* Function 15 */
DWORD ROpenSCManagerW(
- handle_t BindingHandle,
LPWSTR lpMachineName,
LPWSTR lpDatabaseName,
DWORD dwDesiredAccess,
&hHandle);
if (dwError != ERROR_SUCCESS)
{
- DPRINT1("ScmCreateManagerHandle() failed (Error %lu)\n", dwError);
+ DPRINT("ScmCreateManagerHandle() failed (Error %lu)\n", dwError);
return dwError;
}
dwDesiredAccess | SC_MANAGER_CONNECT);
if (dwError != ERROR_SUCCESS)
{
- DPRINT1("ScmCheckAccess() failed (Error %lu)\n", dwError);
+ DPRINT("ScmCheckAccess() failed (Error %lu)\n", dwError);
HeapFree(GetProcessHeap(), 0, hHandle);
return dwError;
}
- *lpScHandle = (unsigned long)hHandle; /* FIXME: 64 bit portability */
+ *lpScHandle = (SC_RPC_HANDLE)hHandle;
DPRINT("*hScm = %p\n", *lpScHandle);
DPRINT("ROpenSCManagerW() done\n");
/* Function 16 */
DWORD ROpenServiceW(
- handle_t BindingHandle,
SC_RPC_HANDLE hSCManager,
LPWSTR lpServiceName,
DWORD dwDesiredAccess,
if (ScmShutdown)
return ERROR_SHUTDOWN_IN_PROGRESS;
- if (!lpServiceHandle)
- return ERROR_INVALID_PARAMETER;
-
- if (!lpServiceName)
- return ERROR_INVALID_ADDRESS;
-
hManager = (PMANAGER_HANDLE)hSCManager;
if (!hManager || hManager->Handle.Tag != MANAGER_TAG)
{
- DPRINT1("Invalid manager handle!\n");
+ DPRINT("Invalid manager handle!\n");
return ERROR_INVALID_HANDLE;
}
+ if (!lpServiceHandle)
+ return ERROR_INVALID_PARAMETER;
+
+ if (!lpServiceName)
+ return ERROR_INVALID_ADDRESS;
+
/* FIXME: Lock the service list */
/* Get service database entry */
&hHandle);
if (dwError != ERROR_SUCCESS)
{
- DPRINT1("ScmCreateServiceHandle() failed (Error %lu)\n", dwError);
+ DPRINT("ScmCreateServiceHandle() failed (Error %lu)\n", dwError);
return dwError;
}
dwDesiredAccess);
if (dwError != ERROR_SUCCESS)
{
- DPRINT1("ScmCheckAccess() failed (Error %lu)\n", dwError);
+ DPRINT("ScmCheckAccess() failed (Error %lu)\n", dwError);
HeapFree(GetProcessHeap(), 0, hHandle);
return dwError;
}
- *lpServiceHandle = (unsigned long)hHandle; /* FIXME: 64 bit portability */
+ lpService->dwRefCount++;
+ DPRINT("OpenService - lpService->dwRefCount %u\n",lpService->dwRefCount);
+
+ *lpServiceHandle = (SC_RPC_HANDLE)hHandle;
DPRINT("*hService = %p\n", *lpServiceHandle);
DPRINT("ROpenServiceW() done\n");
/* Function 17 */
DWORD RQueryServiceConfigW(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
LPBYTE lpBuf, //LPQUERY_SERVICE_CONFIGW lpServiceConfig,
DWORD cbBufSize,
HKEY hServiceKey = NULL;
LPWSTR lpImagePath = NULL;
LPWSTR lpServiceStartName = NULL;
+ LPWSTR lpDependencies = NULL;
+ DWORD dwDependenciesLength = 0;
DWORD dwRequiredSize;
LPQUERY_SERVICE_CONFIGW lpConfig = NULL;
WCHAR lpEmptyString[] = {0,0};
hSvc = (PSERVICE_HANDLE)hService;
if (!hSvc || hSvc->Handle.Tag != SERVICE_TAG)
{
- DPRINT1("Invalid handle tag!\n");
+ DPRINT("Invalid handle tag!\n");
return ERROR_INVALID_HANDLE;
}
if (!RtlAreAllAccessesGranted(hSvc->Handle.DesiredAccess,
SERVICE_QUERY_CONFIG))
{
- DPRINT1("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
+ DPRINT("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
lpService = hSvc->ServiceEntry;
if (lpService == NULL)
{
- DPRINT1("lpService == NULL!\n");
+ DPRINT("lpService == NULL!\n");
return ERROR_INVALID_HANDLE;
}
if (dwError != ERROR_SUCCESS)
goto Done;
+ /* Read the image path */
dwError = ScmReadString(hServiceKey,
L"ImagePath",
&lpImagePath);
if (dwError != ERROR_SUCCESS)
goto Done;
+ /* Read the service start name */
ScmReadString(hServiceKey,
L"ObjectName",
&lpServiceStartName);
+ /* Read the dependencies */
+ ScmReadDependencies(hServiceKey,
+ &lpDependencies,
+ &dwDependenciesLength);
+
dwRequiredSize = sizeof(QUERY_SERVICE_CONFIGW);
if (lpImagePath != NULL)
else
dwRequiredSize += 2 * sizeof(WCHAR);
- /* FIXME: Add Dependencies length*/
+ if (lpDependencies != NULL)
+ dwRequiredSize += dwDependenciesLength * sizeof(WCHAR);
+ else
+ dwRequiredSize += 2 * sizeof(WCHAR);
if (lpServiceStartName != NULL)
dwRequiredSize += ((wcslen(lpServiceStartName) + 1) * sizeof(WCHAR));
lpStr = (LPWSTR)(lpConfig + 1);
+ /* Append the image path */
if (lpImagePath != NULL)
{
wcscpy(lpStr, lpImagePath);
lpConfig->lpBinaryPathName = (LPWSTR)((ULONG_PTR)lpStr - (ULONG_PTR)lpConfig);
lpStr += (wcslen(lpStr) + 1);
+ /* Append the group name */
if (lpService->lpGroup != NULL)
{
wcscpy(lpStr, lpService->lpGroup->lpGroupName);
lpConfig->lpLoadOrderGroup = (LPWSTR)((ULONG_PTR)lpStr - (ULONG_PTR)lpConfig);
lpStr += (wcslen(lpStr) + 1);
- /* FIXME: Append Dependencies */
- wcscpy(lpStr, lpEmptyString);
+ /* Append Dependencies */
+ if (lpDependencies != NULL)
+ {
+ memcpy(lpStr,
+ lpDependencies,
+ dwDependenciesLength * sizeof(WCHAR));
+ }
+ else
+ {
+ wcscpy(lpStr, lpEmptyString);
+ }
- lpStr += (wcslen(lpStr) + 1);
lpConfig->lpDependencies = (LPWSTR)((ULONG_PTR)lpStr - (ULONG_PTR)lpConfig);
+ if (lpDependencies != NULL)
+ lpStr += dwDependenciesLength * sizeof(WCHAR);
+ else
+ lpStr += (wcslen(lpStr) + 1);
+ /* Append the service start name */
if (lpServiceStartName != NULL)
{
wcscpy(lpStr, lpServiceStartName);
lpConfig->lpServiceStartName = (LPWSTR)((ULONG_PTR)lpStr - (ULONG_PTR)lpConfig);
lpStr += (wcslen(lpStr) + 1);
+ /* Append the display name */
if (lpService->lpDisplayName != NULL)
{
wcscpy(lpStr, lpService->lpDisplayName);
if (lpServiceStartName != NULL)
HeapFree(GetProcessHeap(), 0, lpServiceStartName);
+ if (lpDependencies != NULL)
+ HeapFree(GetProcessHeap(), 0, lpDependencies);
+
if (hServiceKey != NULL)
RegCloseKey(hServiceKey);
/* Function 18 */
DWORD RQueryServiceLockStatusW(
- handle_t BindingHandle,
SC_RPC_HANDLE hSCManager,
LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus,
DWORD cbBufSize,
/* Function 19 */
DWORD RStartServiceW(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
DWORD argc,
LPSTRING_PTRSW argv)
hSvc = (PSERVICE_HANDLE)hService;
if (!hSvc || hSvc->Handle.Tag != SERVICE_TAG)
{
- DPRINT1("Invalid handle tag!\n");
+ DPRINT("Invalid handle tag!\n");
return ERROR_INVALID_HANDLE;
}
if (!RtlAreAllAccessesGranted(hSvc->Handle.DesiredAccess,
SERVICE_START))
{
- DPRINT1("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
+ DPRINT("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
lpService = hSvc->ServiceEntry;
if (lpService == NULL)
{
- DPRINT1("lpService == NULL!\n");
+ DPRINT("lpService == NULL!\n");
return ERROR_INVALID_HANDLE;
}
/* Function 20 */
DWORD RGetServiceDisplayNameW(
- handle_t BindingHandle,
SC_RPC_HANDLE hSCManager,
- LPWSTR lpServiceName,
+ LPCWSTR lpServiceName,
LPWSTR lpDisplayName,
DWORD *lpcchBuffer)
{
// hManager = (PMANAGER_HANDLE)hSCManager;
// if (hManager->Handle.Tag != MANAGER_TAG)
// {
-// DPRINT1("Invalid manager handle!\n");
+// DPRINT("Invalid manager handle!\n");
// return ERROR_INVALID_HANDLE;
// }
lpService = ScmGetServiceEntryByName(lpServiceName);
if (lpService == NULL)
{
- DPRINT1("Could not find a service!\n");
+ DPRINT("Could not find a service!\n");
- /* If the service could not be found and lpcchBuffer is 0, windows
- puts null in lpDisplayName and puts 1 in lpcchBuffer */
- if (*lpcchBuffer == 0)
+ /* If the service could not be found and lpcchBuffer is less than 2, windows
+ puts null in lpDisplayName and puts 2 in lpcchBuffer */
+ if (*lpcchBuffer < 2)
{
- *lpcchBuffer = 1;
- *lpDisplayName = '\0';
+ *lpcchBuffer = 2;
+ if (lpDisplayName != NULL)
+ {
+ *lpDisplayName = '\0';
+ }
}
return ERROR_SERVICE_DOES_NOT_EXIST;
{
dwLength = wcslen(lpService->lpServiceName);
- if (lpServiceName != NULL &&
+ if (lpDisplayName != NULL &&
*lpcchBuffer > dwLength)
{
wcscpy(lpDisplayName, lpService->lpServiceName);
/* Function 21 */
DWORD RGetServiceKeyNameW(
- handle_t BindingHandle,
SC_RPC_HANDLE hSCManager,
- LPWSTR lpDisplayName,
+ LPCWSTR lpDisplayName,
LPWSTR lpServiceName,
DWORD *lpcchBuffer)
{
// hManager = (PMANAGER_HANDLE)hSCManager;
// if (hManager->Handle.Tag != MANAGER_TAG)
// {
-// DPRINT1("Invalid manager handle!\n");
+// DPRINT("Invalid manager handle!\n");
// return ERROR_INVALID_HANDLE;
// }
lpService = ScmGetServiceEntryByDisplayName(lpDisplayName);
if (lpService == NULL)
{
- DPRINT1("Could not find a service!\n");
+ DPRINT("Could not find a service!\n");
- /* If the service could not be found and lpcchBuffer is 0, windows
+ /* If the service could not be found and lpcchBuffer is less than 2, windows
puts null in lpDisplayName and puts 2 in lpcchBuffer */
- if (*lpcchBuffer == 0)
+ if (*lpcchBuffer < 2)
{
*lpcchBuffer = 2;
- *lpServiceName = '\0';
+ if (lpServiceName != NULL)
+ {
+ *lpServiceName = '\0';
+ }
}
return ERROR_SERVICE_DOES_NOT_EXIST;
dwError = (*lpcchBuffer > dwLength) ? ERROR_SUCCESS : ERROR_INSUFFICIENT_BUFFER;
- *lpcchBuffer = dwLength * 2;
+ *lpcchBuffer = dwLength;
return dwError;
}
/* Function 22 */
-DWORD RSetServiceBitsA(
- handle_t BindingHandle,
- SC_RPC_HANDLE hServiceStatus,
+DWORD RI_ScSetServiceBitsA(
+ RPC_SERVICE_STATUS_HANDLE hServiceStatus,
DWORD dwServiceBits,
int bSetBitsOn,
int bUpdateImmediately,
/* Function 23 */
DWORD RChangeServiceConfigA(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
DWORD dwServiceType,
DWORD dwStartType,
hSvc = (PSERVICE_HANDLE)hService;
if (!hSvc || hSvc->Handle.Tag != SERVICE_TAG)
{
- DPRINT1("Invalid handle tag!\n");
+ DPRINT("Invalid handle tag!\n");
return ERROR_INVALID_HANDLE;
}
if (!RtlAreAllAccessesGranted(hSvc->Handle.DesiredAccess,
SERVICE_CHANGE_CONFIG))
{
- DPRINT1("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
+ DPRINT("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
lpService = hSvc->ServiceEntry;
if (lpService == NULL)
{
- DPRINT1("lpService == NULL!\n");
+ DPRINT("lpService == NULL!\n");
return ERROR_INVALID_HANDLE;
}
if (lpService->bDeleted)
{
/* FIXME: Unlock database */
- DPRINT1("The service has already been marked for delete!\n");
+ DPRINT("The service has already been marked for delete!\n");
return ERROR_SERVICE_MARKED_FOR_DELETE;
}
lpDisplayName,
-1,
lpDisplayNameW,
- (wcslen(lpDisplayNameW) + 1) * sizeof(WCHAR));
+ strlen(lpDisplayName) + 1);
RegSetValueExW(hServiceKey,
L"DisplayName",
if (lpBinaryPathName != NULL && *lpBinaryPathName != 0)
{
lpBinaryPathNameW=HeapAlloc(GetProcessHeap(),0, (strlen(lpBinaryPathName)+1) * sizeof(WCHAR));
- MultiByteToWideChar(CP_ACP, 0, lpBinaryPathName, -1, lpBinaryPathNameW, (wcslen(lpBinaryPathNameW)+1) * sizeof(WCHAR));
+ MultiByteToWideChar(CP_ACP, 0, lpBinaryPathName, -1, lpBinaryPathNameW, strlen(lpBinaryPathName)+1);
dwError = RegSetValueExW(hServiceKey,
L"ImagePath",
0,
{
lpLoadOrderGroupW = HeapAlloc(GetProcessHeap(),
0,
- (strlen(lpLoadOrderGroup)+1) * sizeof(WCHAR));
+ (strlen(lpLoadOrderGroup) + 1) * sizeof(WCHAR));
if (lpLoadOrderGroupW == NULL)
{
dwError = ERROR_NOT_ENOUGH_MEMORY;
lpLoadOrderGroup,
-1,
lpLoadOrderGroupW,
- (wcslen(lpLoadOrderGroupW) + 1) * sizeof(WCHAR));
+ strlen(lpLoadOrderGroup) + 1);
dwError = RegSetValueExW(hServiceKey,
L"Group",
(LPBYTE)lpLoadOrderGroupW,
(wcslen(lpLoadOrderGroupW) + 1) * sizeof(WCHAR));
if (dwError != ERROR_SUCCESS)
+ {
+ HeapFree(GetProcessHeap(), 0, lpLoadOrderGroupW);
goto done;
+ }
- /* FIXME: Update lpService->lpServiceGroup */
+ dwError = ScmSetServiceGroup(lpService,
+ lpLoadOrderGroupW);
HeapFree(GetProcessHeap(), 0, lpLoadOrderGroupW);
+
+ if (dwError != ERROR_SUCCESS)
+ goto done;
}
if (lpdwTagId != NULL)
{
lpDependenciesW = HeapAlloc(GetProcessHeap(),
0,
- (strlen(lpDependencies)+1) * sizeof(WCHAR));
+ (strlen(lpDependencies) + 1) * sizeof(WCHAR));
if (lpDependenciesW == NULL)
{
dwError = ERROR_NOT_ENOUGH_MEMORY;
lpDependencies,
dwDependSize,
lpDependenciesW,
- (wcslen(lpDependenciesW)+1) * sizeof(WCHAR));
+ strlen(lpDependencies) + 1);
dwError = ScmWriteDependencies(hServiceKey,
(LPWSTR)lpDependenciesW,
/* Function 24 */
DWORD RCreateServiceA(
- handle_t BindingHandle,
SC_RPC_HANDLE hSCManager,
LPSTR lpServiceName,
LPSTR lpDisplayName,
DWORD dwPwSize,
LPSC_RPC_HANDLE lpServiceHandle)
{
- UNIMPLEMENTED;
- return ERROR_CALL_NOT_IMPLEMENTED;
+ DWORD dwError = ERROR_SUCCESS;
+ LPWSTR lpServiceNameW = NULL;
+ LPWSTR lpDisplayNameW = NULL;
+ LPWSTR lpBinaryPathNameW = NULL;
+ LPWSTR lpLoadOrderGroupW = NULL;
+ LPWSTR lpDependenciesW = NULL;
+ LPWSTR lpServiceStartNameW = NULL;
+ DWORD dwDependenciesLength = 0;
+ DWORD dwLength;
+ int len;
+ LPSTR lpStr;
+
+ if (lpServiceName)
+ {
+ len = MultiByteToWideChar(CP_ACP, 0, lpServiceName, -1, NULL, 0);
+ lpServiceNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+ if (!lpServiceNameW)
+ {
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ goto cleanup;
+ }
+ MultiByteToWideChar(CP_ACP, 0, lpServiceName, -1, lpServiceNameW, len);
+ }
+
+ if (lpDisplayName)
+ {
+ len = MultiByteToWideChar(CP_ACP, 0, lpDisplayName, -1, NULL, 0);
+ lpDisplayNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+ if (!lpDisplayNameW)
+ {
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ goto cleanup;
+ }
+ MultiByteToWideChar(CP_ACP, 0, lpDisplayName, -1, lpDisplayNameW, len);
+ }
+
+ if (lpBinaryPathName)
+ {
+ len = MultiByteToWideChar(CP_ACP, 0, lpBinaryPathName, -1, NULL, 0);
+ lpBinaryPathNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+ if (!lpBinaryPathNameW)
+ {
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ goto cleanup;
+ }
+ MultiByteToWideChar(CP_ACP, 0, lpBinaryPathName, -1, lpBinaryPathNameW, len);
+ }
+
+ if (lpLoadOrderGroup)
+ {
+ len = MultiByteToWideChar(CP_ACP, 0, lpLoadOrderGroup, -1, NULL, 0);
+ lpLoadOrderGroupW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+ if (!lpLoadOrderGroupW)
+ {
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ goto cleanup;
+ }
+ MultiByteToWideChar(CP_ACP, 0, lpLoadOrderGroup, -1, lpLoadOrderGroupW, len);
+ }
+
+ if (lpDependencies)
+ {
+ lpStr = (LPSTR)lpDependencies;
+ while (*lpStr)
+ {
+ dwLength = strlen(lpStr) + 1;
+ dwDependenciesLength += dwLength;
+ lpStr = lpStr + dwLength;
+ }
+ dwDependenciesLength++;
+
+ lpDependenciesW = HeapAlloc(GetProcessHeap(), 0, dwDependenciesLength * sizeof(WCHAR));
+ if (!lpDependenciesW)
+ {
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ goto cleanup;
+ }
+ MultiByteToWideChar(CP_ACP, 0, (LPSTR)lpDependencies, dwDependenciesLength, lpDependenciesW, dwDependenciesLength);
+ }
+
+ if (lpServiceStartName)
+ {
+ len = MultiByteToWideChar(CP_ACP, 0, lpServiceStartName, -1, NULL, 0);
+ lpServiceStartNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+ if (!lpServiceStartNameW)
+ {
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ goto cleanup;
+ }
+ MultiByteToWideChar(CP_ACP, 0, lpServiceStartName, -1, lpServiceStartNameW, len);
+ }
+
+ dwError = RCreateServiceW(hSCManager,
+ lpServiceNameW,
+ lpDisplayNameW,
+ dwDesiredAccess,
+ dwServiceType,
+ dwStartType,
+ dwErrorControl,
+ lpBinaryPathNameW,
+ lpLoadOrderGroupW,
+ lpdwTagId,
+ (LPBYTE)lpDependenciesW,
+ dwDependenciesLength,
+ lpServiceStartNameW,
+ lpPassword,
+ dwPwSize,
+ lpServiceHandle);
+
+cleanup:
+ if (lpServiceNameW !=NULL)
+ HeapFree(GetProcessHeap(), 0, lpServiceNameW);
+
+ if (lpDisplayNameW != NULL)
+ HeapFree(GetProcessHeap(), 0, lpDisplayNameW);
+
+ if (lpBinaryPathNameW != NULL)
+ HeapFree(GetProcessHeap(), 0, lpBinaryPathNameW);
+
+ if (lpLoadOrderGroupW != NULL)
+ HeapFree(GetProcessHeap(), 0, lpLoadOrderGroupW);
+
+ if (lpDependenciesW != NULL)
+ HeapFree(GetProcessHeap(), 0, lpDependenciesW);
+
+ if (lpServiceStartNameW != NULL)
+ HeapFree(GetProcessHeap(), 0, lpServiceStartNameW);
+
+ return dwError;
}
/* Function 25 */
DWORD REnumDependentServicesA(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
DWORD dwServiceState,
LPBYTE lpServices,
if (!RtlAreAllAccessesGranted(hSvc->Handle.DesiredAccess,
SC_MANAGER_ENUMERATE_SERVICE))
{
- DPRINT1("Insufficient access rights! 0x%lx\n",
- hSvc->Handle.DesiredAccess);
+ DPRINT("Insufficient access rights! 0x%lx\n",
+ hSvc->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
KEY_READ,
&hServicesKey);
- if (dwError != ERROR_SUCCESS) return dwError;
+ if (dwError != ERROR_SUCCESS)
+ return dwError;
/* NOTE: Windows calculates the pcbBytesNeeded based on WCHAR strings for
both EnumDependentServicesA and EnumDependentServicesW. So returned pcbBytesNeeded
(dwServicesReturned + 1) * sizeof(PSERVICE));
if (!lpServicesArray)
{
- DPRINT1("Could not allocate a buffer!!\n");
+ DPRINT("Could not allocate a buffer!!\n");
dwError = ERROR_NOT_ENOUGH_MEMORY;
goto Done;
}
/* Function 26 */
DWORD REnumServicesStatusA(
- handle_t BindingHandle,
SC_RPC_HANDLE hSCManager,
DWORD dwServiceType,
DWORD dwServiceState,
LPBOUNDED_DWORD_256K lpServicesReturned,
LPBOUNDED_DWORD_256K lpResumeHandle)
{
- UNIMPLEMENTED;
- return ERROR_CALL_NOT_IMPLEMENTED;
+ LPENUM_SERVICE_STATUSW lpStatusPtrW = NULL;
+ LPENUM_SERVICE_STATUSA lpStatusPtrA = NULL;
+ LPWSTR lpStringPtrW;
+ LPSTR lpStringPtrA;
+ DWORD dwError;
+ DWORD dwServiceCount;
+
+ DPRINT("REnumServicesStatusA() called\n");
+
+ if ((dwBufSize > 0) && (lpBuffer))
+ {
+ lpStatusPtrW = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwBufSize);
+ if (!lpStatusPtrW)
+ {
+ DPRINT("Failed to allocate buffer!\n");
+ return ERROR_NOT_ENOUGH_MEMORY;
+ }
+ }
+
+ dwError = REnumServicesStatusW(hSCManager,
+ dwServiceType,
+ dwServiceState,
+ (LPBYTE)lpStatusPtrW,
+ dwBufSize,
+ pcbBytesNeeded,
+ lpServicesReturned,
+ lpResumeHandle);
+
+ /* if no services were returned then we are Done */
+ if (*lpServicesReturned == 0)
+ goto Done;
+
+ lpStatusPtrA = (LPENUM_SERVICE_STATUSA)lpBuffer;
+ lpStringPtrA = (LPSTR)((ULONG_PTR)lpBuffer +
+ *lpServicesReturned * sizeof(ENUM_SERVICE_STATUSA));
+ lpStringPtrW = (LPWSTR)((ULONG_PTR)lpStatusPtrW +
+ *lpServicesReturned * sizeof(ENUM_SERVICE_STATUSW));
+
+ for (dwServiceCount = 0; dwServiceCount < *lpServicesReturned; dwServiceCount++)
+ {
+ /* Copy the service name */
+ WideCharToMultiByte(CP_ACP,
+ 0,
+ lpStringPtrW,
+ -1,
+ lpStringPtrA,
+ wcslen(lpStringPtrW),
+ 0,
+ 0);
+
+ lpStatusPtrA->lpServiceName = (LPSTR)((ULONG_PTR)lpStringPtrA - (ULONG_PTR)lpBuffer);
+ lpStringPtrA += wcslen(lpStringPtrW) + 1;
+ lpStringPtrW += wcslen(lpStringPtrW) + 1;
+
+ /* Copy the display name */
+ WideCharToMultiByte(CP_ACP,
+ 0,
+ lpStringPtrW,
+ -1,
+ lpStringPtrA,
+ wcslen(lpStringPtrW),
+ 0,
+ 0);
+
+ lpStatusPtrA->lpDisplayName = (LPSTR)((ULONG_PTR)lpStringPtrA - (ULONG_PTR)lpBuffer);
+ lpStringPtrA += wcslen(lpStringPtrW) + 1;
+ lpStringPtrW += wcslen(lpStringPtrW) + 1;
+
+ /* Copy the status information */
+ memcpy(&lpStatusPtrA->ServiceStatus,
+ &lpStatusPtrW->ServiceStatus,
+ sizeof(SERVICE_STATUS));
+
+ lpStatusPtrA++;
+ }
+
+Done:;
+ if (lpStatusPtrW)
+ HeapFree(GetProcessHeap(), 0, lpStatusPtrW);
+
+ DPRINT("REnumServicesStatusA() done (Error %lu)\n", dwError);
+
+ return dwError;
}
/* Function 27 */
DWORD ROpenSCManagerA(
- handle_t BindingHandle,
LPSTR lpMachineName,
LPSTR lpDatabaseName,
DWORD dwDesiredAccess,
RtlCreateUnicodeStringFromAsciiz(&DatabaseName,
lpDatabaseName);
- dwError = ROpenSCManagerW(BindingHandle,
- lpMachineName ? MachineName.Buffer : NULL,
+ dwError = ROpenSCManagerW(lpMachineName ? MachineName.Buffer : NULL,
lpDatabaseName ? DatabaseName.Buffer : NULL,
dwDesiredAccess,
lpScHandle);
/* Function 28 */
DWORD ROpenServiceA(
- handle_t BindingHandle,
SC_RPC_HANDLE hSCManager,
LPSTR lpServiceName,
DWORD dwDesiredAccess,
RtlCreateUnicodeStringFromAsciiz(&ServiceName,
lpServiceName);
- dwError = ROpenServiceW(BindingHandle,
- hSCManager,
+ dwError = ROpenServiceW(hSCManager,
lpServiceName ? ServiceName.Buffer : NULL,
dwDesiredAccess,
lpServiceHandle);
/* Function 29 */
DWORD RQueryServiceConfigA(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
LPBYTE lpBuf, //LPQUERY_SERVICE_CONFIGA lpServiceConfig,
DWORD cbBufSize,
HKEY hServiceKey = NULL;
LPWSTR lpImagePath = NULL;
LPWSTR lpServiceStartName = NULL;
+ LPWSTR lpDependencies = NULL;
+ DWORD dwDependenciesLength = 0;
DWORD dwRequiredSize;
LPQUERY_SERVICE_CONFIGA lpConfig = NULL;
CHAR lpEmptyString[]={0,0};
hSvc = (PSERVICE_HANDLE)hService;
if (!hSvc || hSvc->Handle.Tag != SERVICE_TAG)
{
- DPRINT1("Invalid handle tag!\n");
+ DPRINT("Invalid handle tag!\n");
return ERROR_INVALID_HANDLE;
}
if (!RtlAreAllAccessesGranted(hSvc->Handle.DesiredAccess,
SERVICE_QUERY_CONFIG))
{
- DPRINT1("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
+ DPRINT("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
lpService = hSvc->ServiceEntry;
if (lpService == NULL)
{
- DPRINT1("lpService == NULL!\n");
+ DPRINT("lpService == NULL!\n");
return ERROR_INVALID_HANDLE;
}
if (dwError != ERROR_SUCCESS)
goto Done;
+ /* Read the image path */
dwError = ScmReadString(hServiceKey,
L"ImagePath",
&lpImagePath);
if (dwError != ERROR_SUCCESS)
goto Done;
+ /* Read the service start name */
ScmReadString(hServiceKey,
L"ObjectName",
&lpServiceStartName);
+ /* Read the dependencies */
+ ScmReadDependencies(hServiceKey,
+ &lpDependencies,
+ &dwDependenciesLength);
+
dwRequiredSize = sizeof(QUERY_SERVICE_CONFIGW);
if (lpImagePath != NULL)
else
dwRequiredSize += 2;
- if (lpService->lpGroup != NULL)
+ if ((lpService->lpGroup != NULL) && (lpService->lpGroup->lpGroupName != NULL))
dwRequiredSize += wcslen(lpService->lpGroup->lpGroupName) + 1;
else
dwRequiredSize += 2;
- /* FIXME: Add Dependencies length*/
- dwRequiredSize += 2;
+ /* Add Dependencies length */
+ if (lpDependencies != NULL)
+ dwRequiredSize += dwDependenciesLength;
+ else
+ dwRequiredSize += 2;
if (lpServiceStartName != NULL)
dwRequiredSize += wcslen(lpServiceStartName) + 1;
lpImagePath,
-1,
lpStr,
- wcslen(lpImagePath),
+ wcslen(lpImagePath) + 1,
0,
0);
}
lpConfig->lpBinaryPathName = (LPSTR)((ULONG_PTR)lpStr - (ULONG_PTR)lpConfig);
lpStr += (strlen((LPSTR)lpStr) + 1);
- if (lpService->lpGroup)
+ if (lpService->lpGroup && lpService->lpGroup->lpGroupName)
{
WideCharToMultiByte(CP_ACP,
0,
lpService->lpGroup->lpGroupName,
-1,
lpStr,
- wcslen(lpService->lpGroup->lpGroupName),
+ wcslen(lpService->lpGroup->lpGroupName) + 1,
0,
0);
}
lpConfig->lpLoadOrderGroup = (LPSTR)((ULONG_PTR)lpStr - (ULONG_PTR)lpConfig);
lpStr += (strlen(lpStr) + 1);
- /* FIXME: Append Dependencies */
- strcpy(lpStr, lpEmptyString);
+ /* Append Dependencies */
+ if (lpDependencies)
+ {
+ WideCharToMultiByte(CP_ACP,
+ 0,
+ lpDependencies,
+ dwDependenciesLength,
+ lpStr,
+ dwDependenciesLength,
+ 0,
+ 0);
+ }
+ else
+ {
+ strcpy(lpStr, lpEmptyString);
+ }
lpConfig->lpDependencies = (LPSTR)((ULONG_PTR)lpStr - (ULONG_PTR)lpConfig);
- lpStr += (strlen(lpStr) + 1);
+ if (lpDependencies)
+ lpStr += dwDependenciesLength;
+ else
+ lpStr += (strlen(lpStr) + 1);
if (lpServiceStartName)
{
lpServiceStartName,
-1,
lpStr,
- wcslen(lpServiceStartName),
+ wcslen(lpServiceStartName) + 1,
0,
0);
}
lpService->lpDisplayName,
-1,
lpStr,
- wcslen(lpService->lpDisplayName),
+ wcslen(lpService->lpDisplayName) + 1,
0,
0);
}
if (lpServiceStartName != NULL)
HeapFree(GetProcessHeap(), 0, lpServiceStartName);
+ if (lpDependencies != NULL)
+ HeapFree(GetProcessHeap(), 0, lpDependencies);
+
if (hServiceKey != NULL)
RegCloseKey(hServiceKey);
/* Function 30 */
DWORD RQueryServiceLockStatusA(
- handle_t BindingHandle,
SC_RPC_HANDLE hSCManager,
LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus,
DWORD cbBufSize,
/* Function 31 */
DWORD RStartServiceA(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
DWORD argc,
LPSTRING_PTRSA argv)
PSERVICE_HANDLE hSvc;
PSERVICE lpService = NULL;
- DPRINT1("RStartServiceA() called\n");
+ DPRINT("RStartServiceA() called\n");
if (ScmShutdown)
return ERROR_SHUTDOWN_IN_PROGRESS;
hSvc = (PSERVICE_HANDLE)hService;
if (!hSvc || hSvc->Handle.Tag != SERVICE_TAG)
{
- DPRINT1("Invalid handle tag!\n");
+ DPRINT("Invalid handle tag!\n");
return ERROR_INVALID_HANDLE;
}
if (!RtlAreAllAccessesGranted(hSvc->Handle.DesiredAccess,
SERVICE_START))
{
- DPRINT1("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
+ DPRINT("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
lpService = hSvc->ServiceEntry;
if (lpService == NULL)
{
- DPRINT1("lpService == NULL!\n");
+ DPRINT("lpService == NULL!\n");
return ERROR_INVALID_HANDLE;
}
/* Function 32 */
DWORD RGetServiceDisplayNameA(
- handle_t BindingHandle,
SC_RPC_HANDLE hSCManager,
- LPSTR lpServiceName,
+ LPCSTR lpServiceName,
LPSTR lpDisplayName,
LPBOUNDED_DWORD_4K lpcchBuffer)
{
// PMANAGER_HANDLE hManager;
- PSERVICE lpService;
+ PSERVICE lpService = NULL;
DWORD dwLength;
DWORD dwError;
LPWSTR lpServiceNameW;
// hManager = (PMANAGER_HANDLE)hSCManager;
// if (hManager->Handle.Tag != MANAGER_TAG)
// {
-// DPRINT1("Invalid manager handle!\n");
+// DPRINT("Invalid manager handle!\n");
// return ERROR_INVALID_HANDLE;
// }
- dwLength = strlen(lpServiceName) + 1;
- lpServiceNameW = HeapAlloc(GetProcessHeap(),
- HEAP_ZERO_MEMORY,
- dwLength * sizeof(WCHAR));
- if (!lpServiceNameW)
- return ERROR_NOT_ENOUGH_MEMORY;
+ if (lpServiceName != NULL)
+ {
+ dwLength = strlen(lpServiceName) + 1;
+ lpServiceNameW = HeapAlloc(GetProcessHeap(),
+ HEAP_ZERO_MEMORY,
+ dwLength * sizeof(WCHAR));
+ if (!lpServiceNameW)
+ return ERROR_NOT_ENOUGH_MEMORY;
- MultiByteToWideChar(CP_ACP,
- 0,
- lpServiceName,
- strlen(lpServiceName),
- lpServiceNameW,
- dwLength);
+ MultiByteToWideChar(CP_ACP,
+ 0,
+ lpServiceName,
+ -1,
+ lpServiceNameW,
+ dwLength);
- lpService = ScmGetServiceEntryByName(lpServiceNameW);
+ lpService = ScmGetServiceEntryByName(lpServiceNameW);
- HeapFree(GetProcessHeap(), 0, lpServiceNameW);
+ HeapFree(GetProcessHeap(), 0, lpServiceNameW);
+ }
if (lpService == NULL)
{
- DPRINT1("Could not find a service!\n");
+ DPRINT("Could not find a service!\n");
/* If the service could not be found and lpcchBuffer is 0, windows
puts null in lpDisplayName and puts 1 in lpcchBuffer */
if (*lpcchBuffer == 0)
{
*lpcchBuffer = 1;
- *lpDisplayName = '\0';
+ if (lpDisplayName != NULL)
+ {
+ *lpDisplayName = '\0';
+ }
}
return ERROR_SERVICE_DOES_NOT_EXIST;
}
if (!lpService->lpDisplayName)
{
dwLength = wcslen(lpService->lpServiceName);
- if (lpServiceName != NULL &&
+ if (lpDisplayName != NULL &&
*lpcchBuffer > dwLength)
{
WideCharToMultiByte(CP_ACP,
lpService->lpServiceName,
wcslen(lpService->lpServiceName),
lpDisplayName,
- *lpcchBuffer,
+ dwLength + 1,
NULL,
NULL);
return ERROR_SUCCESS;
lpService->lpDisplayName,
wcslen(lpService->lpDisplayName),
lpDisplayName,
- *lpcchBuffer,
+ dwLength + 1,
NULL,
NULL);
return ERROR_SUCCESS;
/* Function 33 */
DWORD RGetServiceKeyNameA(
- handle_t BindingHandle,
SC_RPC_HANDLE hSCManager,
- LPSTR lpDisplayName,
+ LPCSTR lpDisplayName,
LPSTR lpServiceName,
LPBOUNDED_DWORD_4K lpcchBuffer)
{
MultiByteToWideChar(CP_ACP,
0,
lpDisplayName,
- strlen(lpDisplayName),
+ -1,
lpDisplayNameW,
dwLength);
if (lpService == NULL)
{
- DPRINT1("Could not find the service!\n");
+ DPRINT("Could not find the service!\n");
/* If the service could not be found and lpcchBuffer is 0,
put null in lpDisplayName and puts 1 in lpcchBuffer, verified WINXP. */
if (*lpcchBuffer == 0)
{
*lpcchBuffer = 1;
- *lpServiceName = '\0';
+ if (lpServiceName != NULL)
+ {
+ *lpServiceName = '\0';
+ }
}
return ERROR_SERVICE_DOES_NOT_EXIST;
}
dwLength = wcslen(lpService->lpServiceName);
- if (lpService != NULL &&
+ if (lpServiceName != NULL &&
*lpcchBuffer > dwLength)
{
WideCharToMultiByte(CP_ACP,
lpService->lpServiceName,
wcslen(lpService->lpServiceName),
lpServiceName,
- dwLength,
+ dwLength + 1,
NULL,
NULL);
return ERROR_SUCCESS;
/* Function 34 */
-DWORD RGetCurrentGroupStateW(
- handle_t BindingHandle)
+DWORD RI_ScGetCurrentGroupStateW(
+ SC_RPC_HANDLE hSCManager,
+ LPWSTR lpLoadOrderGroup,
+ LPDWORD lpState)
{
UNIMPLEMENTED;
return ERROR_CALL_NOT_IMPLEMENTED;
/* Function 35 */
DWORD REnumServiceGroupW(
- handle_t BindingHandle,
SC_RPC_HANDLE hSCManager,
DWORD dwServiceType,
DWORD dwServiceState,
}
+//
+// WARNING: This function is untested
+//
/* Function 36 */
DWORD RChangeServiceConfig2A(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
SC_RPC_CONFIG_INFOA Info)
{
- UNIMPLEMENTED;
- return ERROR_CALL_NOT_IMPLEMENTED;
+ SC_RPC_CONFIG_INFOW InfoW;
+ DWORD dwRet, dwLength;
+ PVOID ptr = NULL;
+
+ DPRINT("RChangeServiceConfig2A() called\n");
+ DPRINT("dwInfoLevel = %lu\n", Info.dwInfoLevel);
+
+ InfoW.dwInfoLevel = Info.dwInfoLevel;
+
+ if (InfoW.dwInfoLevel == SERVICE_CONFIG_DESCRIPTION)
+ {
+ LPSERVICE_DESCRIPTIONW lpServiceDescriptonW;
+ LPSERVICE_DESCRIPTIONA lpServiceDescriptonA;
+
+ lpServiceDescriptonA = Info.psd;
+
+ ///if (lpServiceDescriptonA &&
+ ///lpServiceDescriptonA->lpDescription)
+ ///{
+ dwLength = (strlen(Info.lpDescription) + 1) * sizeof(WCHAR);
+
+ lpServiceDescriptonW = HeapAlloc(GetProcessHeap(),
+ 0,
+ dwLength + sizeof(SERVICE_DESCRIPTIONW));
+ if (!lpServiceDescriptonW)
+ {
+ return ERROR_NOT_ENOUGH_MEMORY;
+ }
+
+ lpServiceDescriptonW->lpDescription = (LPWSTR)(lpServiceDescriptonW + 1);
+
+ MultiByteToWideChar(CP_ACP,
+ 0,
+ Info.lpDescription,
+ -1,
+ lpServiceDescriptonW->lpDescription,
+ dwLength);
+
+ ptr = lpServiceDescriptonW;
+ InfoW.psd = lpServiceDescriptonW;
+ ///}
+ }
+ else if (Info.dwInfoLevel == SERVICE_CONFIG_FAILURE_ACTIONS)
+ {
+ LPSERVICE_FAILURE_ACTIONSW lpServiceFailureActionsW;
+ LPSERVICE_FAILURE_ACTIONSA lpServiceFailureActionsA;
+ DWORD dwRebootLen = 0;
+ DWORD dwCommandLen = 0;
+
+ lpServiceFailureActionsA = Info.psfa;
+
+ if (lpServiceFailureActionsA)
+ {
+ if (lpServiceFailureActionsA->lpRebootMsg)
+ {
+ dwRebootLen = (strlen(lpServiceFailureActionsA->lpRebootMsg) + 1) * sizeof(WCHAR);
+ }
+ if (lpServiceFailureActionsA->lpCommand)
+ {
+ dwCommandLen = (strlen(lpServiceFailureActionsA->lpCommand) + 1) * sizeof(WCHAR);
+ }
+ dwLength = dwRebootLen + dwCommandLen + sizeof(SERVICE_FAILURE_ACTIONSW);
+
+ lpServiceFailureActionsW = HeapAlloc(GetProcessHeap(),
+ 0,
+ dwLength);
+ if (!lpServiceFailureActionsW)
+ {
+ return ERROR_NOT_ENOUGH_MEMORY;
+ }
+
+ lpServiceFailureActionsW->cActions = lpServiceFailureActionsA->cActions;
+ lpServiceFailureActionsW->dwResetPeriod = lpServiceFailureActionsA->dwResetPeriod;
+ CopyMemory(lpServiceFailureActionsW->lpsaActions, lpServiceFailureActionsA->lpsaActions, sizeof(SC_ACTION));
+
+ if (lpServiceFailureActionsA->lpRebootMsg)
+ {
+ MultiByteToWideChar(CP_ACP,
+ 0,
+ lpServiceFailureActionsA->lpRebootMsg,
+ -1,
+ lpServiceFailureActionsW->lpRebootMsg,
+ dwRebootLen);
+ }
+
+ if (lpServiceFailureActionsA->lpCommand)
+ {
+ MultiByteToWideChar(CP_ACP,
+ 0,
+ lpServiceFailureActionsA->lpCommand,
+ -1,
+ lpServiceFailureActionsW->lpCommand,
+ dwCommandLen);
+ }
+
+ ptr = lpServiceFailureActionsW;
+ }
+ }
+
+ dwRet = RChangeServiceConfig2W(hService, InfoW);
+
+ HeapFree(GetProcessHeap(), 0, ptr);
+
+ return dwRet;
}
/* Function 37 */
DWORD RChangeServiceConfig2W(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
SC_RPC_CONFIG_INFOW Info)
{
hSvc = (PSERVICE_HANDLE)hService;
if (!hSvc || hSvc->Handle.Tag != SERVICE_TAG)
{
- DPRINT1("Invalid handle tag!\n");
+ DPRINT("Invalid handle tag!\n");
return ERROR_INVALID_HANDLE;
}
if (!RtlAreAllAccessesGranted(hSvc->Handle.DesiredAccess,
SERVICE_CHANGE_CONFIG))
{
- DPRINT1("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
+ DPRINT("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
lpService = hSvc->ServiceEntry;
if (lpService == NULL)
{
- DPRINT1("lpService == NULL!\n");
+ DPRINT("lpService == NULL!\n");
return ERROR_INVALID_HANDLE;
}
if (lpService->bDeleted)
{
/* FIXME: Unlock database */
- DPRINT1("The service has already been marked for delete!\n");
+ DPRINT("The service has already been marked for delete!\n");
return ERROR_SERVICE_MARKED_FOR_DELETE;
}
if (dwError != ERROR_SUCCESS)
goto done;
- if (Info.dwInfoLevel & SERVICE_CONFIG_DESCRIPTION)
+ if (Info.dwInfoLevel == SERVICE_CONFIG_DESCRIPTION)
{
LPSERVICE_DESCRIPTIONW lpServiceDescription;
- lpServiceDescription = (LPSERVICE_DESCRIPTIONW)&Info;
- lpServiceDescription->lpDescription = (LPWSTR)(&Info + sizeof(LPSERVICE_DESCRIPTIONW));
+ lpServiceDescription = (LPSERVICE_DESCRIPTIONW)Info.psd;
+ lpServiceDescription->lpDescription = (LPWSTR)((ULONG_PTR)lpServiceDescription + sizeof(LPSERVICE_DESCRIPTIONW));
if (lpServiceDescription != NULL &&
lpServiceDescription->lpDescription != NULL)
{
+ DPRINT("Setting value %S\n", lpServiceDescription->lpDescription);
RegSetValueExW(hServiceKey,
L"Description",
0,
goto done;
}
}
- else if (Info.dwInfoLevel & SERVICE_CONFIG_FAILURE_ACTIONS)
+ else if (Info.dwInfoLevel == SERVICE_CONFIG_FAILURE_ACTIONS)
{
UNIMPLEMENTED;
dwError = ERROR_CALL_NOT_IMPLEMENTED;
/* Function 38 */
DWORD RQueryServiceConfig2A(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
DWORD dwInfoLevel,
LPBYTE lpBuffer,
PSERVICE_HANDLE hSvc;
PSERVICE lpService = NULL;
HKEY hServiceKey = NULL;
- DWORD dwRequiredSize;
LPWSTR lpDescriptionW = NULL;
LPSTR lpDescription = NULL;
- DPRINT("RQueryServiceConfig2W() called\n");
+ DPRINT("RQueryServiceConfig2A() called hService %p dwInfoLevel %u, lpBuffer %p cbBufSize %u pcbBytesNeeded %p\n",
+ hService, dwInfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
if (!lpBuffer)
return ERROR_INVALID_ADDRESS;
hSvc = (PSERVICE_HANDLE)hService;
if (!hSvc || hSvc->Handle.Tag != SERVICE_TAG)
{
- DPRINT1("Invalid handle tag!\n");
+ DPRINT("Invalid handle tag!\n");
return ERROR_INVALID_HANDLE;
}
if (!RtlAreAllAccessesGranted(hSvc->Handle.DesiredAccess,
SERVICE_QUERY_CONFIG))
{
- DPRINT1("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
+ DPRINT("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
lpService = hSvc->ServiceEntry;
if (lpService == NULL)
{
- DPRINT1("lpService == NULL!\n");
+ DPRINT("lpService == NULL!\n");
return ERROR_INVALID_HANDLE;
}
if (dwError != ERROR_SUCCESS)
goto done;
- if (dwInfoLevel & SERVICE_CONFIG_DESCRIPTION)
+ if (dwInfoLevel == SERVICE_CONFIG_DESCRIPTION)
{
LPSERVICE_DESCRIPTIONA lpServiceDescription = (LPSERVICE_DESCRIPTIONA)lpBuffer;
LPSTR lpStr;
+ *pcbBytesNeeded = sizeof(SERVICE_DESCRIPTIONA);
+
dwError = ScmReadString(hServiceKey,
L"Description",
&lpDescriptionW);
- if (dwError != ERROR_SUCCESS)
- goto done;
+ if (dwError == ERROR_SUCCESS)
+ {
+ *pcbBytesNeeded += ((wcslen(lpDescriptionW) + 1) * sizeof(WCHAR));
+ }
- dwRequiredSize = sizeof(SERVICE_DESCRIPTIONA) + ((wcslen(lpDescriptionW) + 1));
+ if (cbBufSize >= *pcbBytesNeeded)
+ {
- if (cbBufSize < dwRequiredSize)
+ if (dwError == ERROR_SUCCESS)
+ {
+ lpStr = (LPSTR)(lpServiceDescription + 1);
+
+ WideCharToMultiByte(CP_ACP,
+ 0,
+ lpDescriptionW,
+ -1,
+ lpStr,
+ wcslen(lpDescriptionW),
+ NULL,
+ NULL);
+ lpServiceDescription->lpDescription = (LPSTR)((ULONG_PTR)lpStr - (ULONG_PTR)lpServiceDescription);
+ }
+ else
+ {
+ lpServiceDescription->lpDescription = NULL;
+ goto done;
+ }
+ }
+ else
{
- *pcbBytesNeeded = dwRequiredSize;
dwError = ERROR_INSUFFICIENT_BUFFER;
goto done;
}
-
- lpStr = (LPSTR)(lpServiceDescription + 1);
-
- WideCharToMultiByte(CP_ACP,
- 0,
- lpDescriptionW,
- -1,
- lpStr,
- wcslen(lpDescriptionW),
- NULL,
- NULL);
- lpServiceDescription->lpDescription = (LPSTR)((ULONG_PTR)lpStr - (ULONG_PTR)lpServiceDescription);
}
else if (dwInfoLevel & SERVICE_CONFIG_FAILURE_ACTIONS)
{
/* Function 39 */
DWORD RQueryServiceConfig2W(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
DWORD dwInfoLevel,
LPBYTE lpBuffer,
HKEY hServiceKey = NULL;
DWORD dwRequiredSize;
LPWSTR lpDescription = NULL;
+ LPWSTR lpFailureCommand = NULL;
+ LPWSTR lpRebootMessage = NULL;
DPRINT("RQueryServiceConfig2W() called\n");
hSvc = (PSERVICE_HANDLE)hService;
if (!hSvc || hSvc->Handle.Tag != SERVICE_TAG)
{
- DPRINT1("Invalid handle tag!\n");
+ DPRINT("Invalid handle tag!\n");
return ERROR_INVALID_HANDLE;
}
if (!RtlAreAllAccessesGranted(hSvc->Handle.DesiredAccess,
SERVICE_QUERY_CONFIG))
{
- DPRINT1("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
+ DPRINT("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
lpService = hSvc->ServiceEntry;
if (lpService == NULL)
{
- DPRINT1("lpService == NULL!\n");
+ DPRINT("lpService == NULL!\n");
return ERROR_INVALID_HANDLE;
}
if (dwError != ERROR_SUCCESS)
goto done;
- if (dwInfoLevel & SERVICE_CONFIG_DESCRIPTION)
+ if (dwInfoLevel == SERVICE_CONFIG_DESCRIPTION)
{
LPSERVICE_DESCRIPTIONW lpServiceDescription = (LPSERVICE_DESCRIPTIONW)lpBuffer;
LPWSTR lpStr;
wcscpy(lpStr, lpDescription);
lpServiceDescription->lpDescription = (LPWSTR)((ULONG_PTR)lpStr - (ULONG_PTR)lpServiceDescription);
}
- else if (dwInfoLevel & SERVICE_CONFIG_FAILURE_ACTIONS)
+ else if (dwInfoLevel == SERVICE_CONFIG_FAILURE_ACTIONS)
{
+ LPWSTR lpStr;
+ LPSERVICE_FAILURE_ACTIONSW lpFailureActions = (LPSERVICE_FAILURE_ACTIONSW)lpBuffer;
+
UNIMPLEMENTED;
- dwError = ERROR_CALL_NOT_IMPLEMENTED;
+
+ dwError = ScmReadString(hServiceKey,
+ L"FailureCommand",
+ &lpFailureCommand);
+
+ dwError = ScmReadString(hServiceKey,
+ L"RebootMessage",
+ &lpRebootMessage);
+
+ dwRequiredSize = sizeof(SERVICE_FAILURE_ACTIONSW);
+
+ if (lpFailureCommand)
+ dwRequiredSize += (wcslen(lpFailureCommand) + 1) * sizeof(WCHAR);
+
+ if (lpRebootMessage)
+ dwRequiredSize += (wcslen(lpRebootMessage) + 1) * sizeof(WCHAR);
+
+ if (cbBufSize < dwRequiredSize)
+ {
+ *pcbBytesNeeded = dwRequiredSize;
+ dwError = ERROR_INSUFFICIENT_BUFFER;
+ goto done;
+ }
+
+ lpFailureActions->cActions = 0;
+ lpFailureActions->dwResetPeriod = 0;
+ lpFailureActions->lpCommand = NULL;
+ lpFailureActions->lpRebootMsg = NULL;
+ lpFailureActions->lpsaActions = NULL;
+
+ lpStr = (LPWSTR)(lpFailureActions + 1);
+ if (lpRebootMessage)
+ {
+ wcscpy(lpStr, lpRebootMessage);
+ lpFailureActions->lpRebootMsg = (LPWSTR)((ULONG_PTR)lpStr - (ULONG_PTR)lpRebootMessage);
+ lpStr += wcslen(lpRebootMessage) + 1;
+ }
+
+ if (lpFailureCommand)
+ {
+ wcscpy(lpStr, lpFailureCommand);
+ lpFailureActions->lpCommand = (LPWSTR)((ULONG_PTR)lpStr - (ULONG_PTR)lpFailureCommand);
+ lpStr += wcslen(lpRebootMessage) + 1;
+ }
+ dwError = STATUS_SUCCESS;
goto done;
}
if (lpDescription != NULL)
HeapFree(GetProcessHeap(), 0, lpDescription);
+ if (lpRebootMessage != NULL)
+ HeapFree(GetProcessHeap(), 0, lpRebootMessage);
+
+ if (lpFailureCommand != NULL)
+ HeapFree(GetProcessHeap(), 0, lpFailureCommand);
+
if (hServiceKey != NULL)
RegCloseKey(hServiceKey);
/* Function 40 */
DWORD RQueryServiceStatusEx(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
SC_STATUS_TYPE InfoLevel,
LPBYTE lpBuffer,
hSvc = (PSERVICE_HANDLE)hService;
if (!hSvc || hSvc->Handle.Tag != SERVICE_TAG)
{
- DPRINT1("Invalid handle tag!\n");
+ DPRINT("Invalid handle tag!\n");
return ERROR_INVALID_HANDLE;
}
if (!RtlAreAllAccessesGranted(hSvc->Handle.DesiredAccess,
SERVICE_QUERY_STATUS))
{
- DPRINT1("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
+ DPRINT("Insufficient access rights! 0x%lx\n", hSvc->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
lpService = hSvc->ServiceEntry;
if (lpService == NULL)
{
- DPRINT1("lpService == NULL!\n");
+ DPRINT("lpService == NULL!\n");
return ERROR_INVALID_HANDLE;
}
/* Function 41 */
DWORD REnumServicesStatusExA(
- handle_t BindingHandle,
SC_RPC_HANDLE hSCManager,
SC_ENUM_TYPE InfoLevel,
DWORD dwServiceType,
LPBOUNDED_DWORD_256K lpResumeIndex,
LPCSTR pszGroupName)
{
- UNIMPLEMENTED;
- *pcbBytesNeeded = 0;
- *lpServicesReturned = 0;
- return ERROR_CALL_NOT_IMPLEMENTED;
+ LPENUM_SERVICE_STATUS_PROCESSW lpStatusPtrW = NULL;
+ LPENUM_SERVICE_STATUS_PROCESSA lpStatusPtrA = NULL;
+ LPWSTR lpStringPtrW;
+ LPSTR lpStringPtrA;
+ LPWSTR pszGroupNameW = NULL;
+ DWORD dwError;
+ DWORD dwServiceCount;
+
+ DPRINT("REnumServicesStatusExA() called\n");
+
+ if (pszGroupName)
+ {
+ pszGroupNameW = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (strlen(pszGroupName) + 1) * sizeof(WCHAR));
+ if (!pszGroupNameW)
+ {
+ DPRINT("Failed to allocate buffer!\n");
+ return ERROR_NOT_ENOUGH_MEMORY;
+ }
+
+ MultiByteToWideChar(CP_ACP,
+ 0,
+ pszGroupName,
+ -1,
+ pszGroupNameW,
+ strlen(pszGroupName) + 1);
+ }
+
+ if ((cbBufSize > 0) && (lpBuffer))
+ {
+ lpStatusPtrW = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cbBufSize);
+ if (!lpStatusPtrW)
+ {
+ DPRINT("Failed to allocate buffer!\n");
+ return ERROR_NOT_ENOUGH_MEMORY;
+ }
+ }
+
+ dwError = REnumServicesStatusExW(hSCManager,
+ InfoLevel,
+ dwServiceType,
+ dwServiceState,
+ (LPBYTE)lpStatusPtrW,
+ cbBufSize,
+ pcbBytesNeeded,
+ lpServicesReturned,
+ lpResumeIndex,
+ pszGroupNameW);
+
+ /* if no services were returned then we are Done */
+ if (*lpServicesReturned == 0)
+ goto Done;
+
+ lpStatusPtrA = (LPENUM_SERVICE_STATUS_PROCESSA)lpBuffer;
+ lpStringPtrA = (LPSTR)((ULONG_PTR)lpBuffer +
+ *lpServicesReturned * sizeof(ENUM_SERVICE_STATUS_PROCESSA));
+ lpStringPtrW = (LPWSTR)((ULONG_PTR)lpStatusPtrW +
+ *lpServicesReturned * sizeof(ENUM_SERVICE_STATUS_PROCESSW));
+
+ for (dwServiceCount = 0; dwServiceCount < *lpServicesReturned; dwServiceCount++)
+ {
+ /* Copy the service name */
+ WideCharToMultiByte(CP_ACP,
+ 0,
+ lpStringPtrW,
+ -1,
+ lpStringPtrA,
+ wcslen(lpStringPtrW),
+ 0,
+ 0);
+
+ lpStatusPtrA->lpServiceName = (LPSTR)((ULONG_PTR)lpStringPtrA - (ULONG_PTR)lpBuffer);
+ lpStringPtrA += wcslen(lpStringPtrW) + 1;
+ lpStringPtrW += wcslen(lpStringPtrW) + 1;
+
+ /* Copy the display name */
+ WideCharToMultiByte(CP_ACP,
+ 0,
+ lpStringPtrW,
+ -1,
+ lpStringPtrA,
+ wcslen(lpStringPtrW),
+ 0,
+ 0);
+
+ lpStatusPtrA->lpDisplayName = (LPSTR)((ULONG_PTR)lpStringPtrA - (ULONG_PTR)lpBuffer);
+ lpStringPtrA += wcslen(lpStringPtrW) + 1;
+ lpStringPtrW += wcslen(lpStringPtrW) + 1;
+
+ /* Copy the status information */
+ memcpy(&lpStatusPtrA->ServiceStatusProcess,
+ &lpStatusPtrW->ServiceStatusProcess,
+ sizeof(SERVICE_STATUS));
+
+ lpStatusPtrA->ServiceStatusProcess.dwProcessId = lpStatusPtrW->ServiceStatusProcess.dwProcessId; /* FIXME */
+ lpStatusPtrA->ServiceStatusProcess.dwServiceFlags = 0; /* FIXME */
+ lpStatusPtrA++;
+ }
+
+Done:;
+ if (pszGroupNameW)
+ HeapFree(GetProcessHeap(), 0, pszGroupNameW);
+
+ if (lpStatusPtrW)
+ HeapFree(GetProcessHeap(), 0, lpStatusPtrW);
+
+ DPRINT("REnumServicesStatusExA() done (Error %lu)\n", dwError);
+
+ return dwError;
}
/* Function 42 */
DWORD REnumServicesStatusExW(
- handle_t BindingHandle,
SC_RPC_HANDLE hSCManager,
SC_ENUM_TYPE InfoLevel,
DWORD dwServiceType,
DWORD dwRequiredSize;
DWORD dwServiceCount;
DWORD dwSize;
- DWORD dwLastResumeCount;
+ DWORD dwLastResumeCount = 0;
LPENUM_SERVICE_STATUS_PROCESSW lpStatusPtr;
LPWSTR lpStringPtr;
hManager = (PMANAGER_HANDLE)hSCManager;
if (!hManager || hManager->Handle.Tag != MANAGER_TAG)
{
- DPRINT1("Invalid manager handle!\n");
+ DPRINT("Invalid manager handle!\n");
return ERROR_INVALID_HANDLE;
}
+ *pcbBytesNeeded = 0;
+ *lpServicesReturned = 0;
+
+ if ((dwServiceType!=SERVICE_DRIVER) && (dwServiceType!=SERVICE_WIN32))
+ {
+ DPRINT("Not a valid Service Type!\n");
+ return ERROR_INVALID_PARAMETER;
+ }
+
+ if ((dwServiceState<SERVICE_ACTIVE) || (dwServiceState>SERVICE_STATE_ALL))
+ {
+ DPRINT("Not a valid Service State!\n");
+ return ERROR_INVALID_PARAMETER;
+ }
+
/* Check access rights */
if (!RtlAreAllAccessesGranted(hManager->Handle.DesiredAccess,
SC_MANAGER_ENUMERATE_SERVICE))
{
- DPRINT1("Insufficient access rights! 0x%lx\n",
- hManager->Handle.DesiredAccess);
+ DPRINT("Insufficient access rights! 0x%lx\n",
+ hManager->Handle.DesiredAccess);
return ERROR_ACCESS_DENIED;
}
- *pcbBytesNeeded = 0;
- *lpServicesReturned = 0;
-
- dwLastResumeCount = *lpResumeIndex;
+ if (lpResumeIndex) dwLastResumeCount = *lpResumeIndex;
/* Lock the service list shared */
DPRINT("*pcbBytesNeeded: %lu\n", dwRequiredSize);
- *lpResumeIndex = dwLastResumeCount;
+ if (lpResumeIndex)
+ *lpResumeIndex = dwLastResumeCount;
+
*lpServicesReturned = dwServiceCount;
*pcbBytesNeeded = dwRequiredSize;
+ /* If there was no services that matched */
+ if ((!dwServiceCount) && (dwError != ERROR_MORE_DATA))
+ {
+ dwError = ERROR_SERVICE_DOES_NOT_EXIST;
+ goto Done;
+ }
+
lpStatusPtr = (LPENUM_SERVICE_STATUS_PROCESSW)lpBuffer;
lpStringPtr = (LPWSTR)((ULONG_PTR)lpBuffer +
dwServiceCount * sizeof(ENUM_SERVICE_STATUS_PROCESSW));
{
break;
}
+ }
+ if (dwError == 0)
+ {
+ *pcbBytesNeeded = 0;
+ if (lpResumeIndex)
+ *lpResumeIndex = 0;
}
Done:;
/* Function 43 */
DWORD RSendTSMessage(
- handle_t BindingHandle)
+ handle_t BindingHandle) /* FIXME */
{
UNIMPLEMENTED;
return ERROR_CALL_NOT_IMPLEMENTED;
/* Function 46 */
DWORD RQueryServiceTagInfo(
- handle_t BindingHandle)
+ handle_t BindingHandle) /* FIXME */
{
UNIMPLEMENTED;
return ERROR_CALL_NOT_IMPLEMENTED;
/* Function 47 */
DWORD RNotifyServiceStatusChange(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
SC_RPC_NOTIFY_PARAMS NotifyParams,
GUID *pClientProcessGuid,
/* Function 48 */
DWORD RGetNotifyResults(
- handle_t BindingHandle,
SC_NOTIFY_RPC_HANDLE hNotify,
PSC_RPC_NOTIFY_PARAMS_LIST *ppNotifyParams)
{
/* Function 49 */
DWORD RCloseNotifyHandle(
- handle_t BindingHandle,
LPSC_NOTIFY_RPC_HANDLE phNotify,
PBOOL pfApcFired)
{
/* Function 50 */
DWORD RControlServiceExA(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
DWORD dwControl,
DWORD dwInfoLevel)
/* Function 51 */
DWORD RControlServiceExW(
- handle_t BindingHandle,
SC_RPC_HANDLE hService,
DWORD dwControl,
DWORD dwInfoLevel)
/* Function 52 */
DWORD RSendPnPMessage(
- handle_t BindingHandle)
+ handle_t BindingHandle) /* FIXME */
{
UNIMPLEMENTED;
return ERROR_CALL_NOT_IMPLEMENTED;
/* Function 53 */
DWORD RValidatePnPService(
- handle_t BindingHandle)
+ handle_t BindingHandle) /* FIXME */
{
UNIMPLEMENTED;
return ERROR_CALL_NOT_IMPLEMENTED;
/* Function 54 */
DWORD ROpenServiceStatusHandle(
- handle_t BindingHandle)
+ handle_t BindingHandle) /* FIXME */
{
UNIMPLEMENTED;
return ERROR_CALL_NOT_IMPLEMENTED;
/* Function 55 */
DWORD RFunction55(
- handle_t BindingHandle)
+ handle_t BindingHandle) /* FIXME */
{
UNIMPLEMENTED;
return ERROR_CALL_NOT_IMPLEMENTED;
}
-void __RPC_FAR * __RPC_USER midl_user_allocate(size_t len)
+void __RPC_FAR * __RPC_USER midl_user_allocate(SIZE_T len)
{
return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
}
{
}
-
/* EOF */
projects / reactos.git / blobdiff