ReactOS  0.4.15-dev-2985-g54406bf
scm.c
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: See COPYING in the top level directory
3  * PROJECT: ReactOS system libraries
4  * FILE: lib/advapi32/service/scm.c
5  * PURPOSE: Service control manager functions
6  * PROGRAMMER: Emanuele Aliberti
7  * Eric Kohl
8  * Pierre Schweitzer
9  */
10 
11 /* INCLUDES ******************************************************************/
12 
13 #include <advapi32.h>
15 
17 WINAPI
19  const struct ustring *in,
20  const struct ustring *key,
21  struct ustring *out);
22 
24 WINAPI
26  IN PVOID ContextHandle,
27  OUT LPBYTE SessionKey);
28 
29 /* FUNCTIONS *****************************************************************/
30 
33 {
35  RPC_CSTR pszStringBinding;
37 
38  TRACE("SVCCTL_HANDLEA_bind(%s)\n",
39  debugstr_a(szMachineName));
40 
42  (RPC_CSTR)"ncacn_np",
43  (RPC_CSTR)szMachineName,
44  (RPC_CSTR)"\\pipe\\ntsvcs",
45  NULL,
46  &pszStringBinding);
47  if (status != RPC_S_OK)
48  {
49  ERR("RpcStringBindingCompose returned 0x%x\n", status);
50  return NULL;
51  }
52 
53  /* Set the binding handle that will be used to bind to the server. */
54  status = RpcBindingFromStringBindingA(pszStringBinding,
55  &hBinding);
56  if (status != RPC_S_OK)
57  {
58  ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
59  }
60 
61  status = RpcStringFreeA(&pszStringBinding);
62  if (status != RPC_S_OK)
63  {
64  ERR("RpcStringFree returned 0x%x\n", status);
65  }
66 
67  return hBinding;
68 }
69 
70 
71 void __RPC_USER
74 {
76 
77  TRACE("SVCCTL_HANDLEA_unbind(%s %p)\n",
78  debugstr_a(szMachineName), hBinding);
79 
81  if (status != RPC_S_OK)
82  {
83  ERR("RpcBindingFree returned 0x%x\n", status);
84  }
85 }
86 
87 
90 {
92  RPC_WSTR pszStringBinding;
94 
95  TRACE("SVCCTL_HANDLEW_bind(%s)\n",
96  debugstr_w(szMachineName));
97 
99  L"ncacn_np",
100  szMachineName,
101  L"\\pipe\\ntsvcs",
102  NULL,
103  &pszStringBinding);
104  if (status != RPC_S_OK)
105  {
106  ERR("RpcStringBindingCompose returned 0x%x\n", status);
107  return NULL;
108  }
109 
110  /* Set the binding handle that will be used to bind to the server. */
111  status = RpcBindingFromStringBindingW(pszStringBinding,
112  &hBinding);
113  if (status != RPC_S_OK)
114  {
115  ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
116  }
117 
118  status = RpcStringFreeW(&pszStringBinding);
119  if (status != RPC_S_OK)
120  {
121  ERR("RpcStringFree returned 0x%x\n", status);
122  }
123 
124  return hBinding;
125 }
126 
127 
128 void __RPC_USER
131 {
133 
134  TRACE("SVCCTL_HANDLEW_unbind(%s %p)\n",
135  debugstr_w(szMachineName), hBinding);
136 
138  if (status != RPC_S_OK)
139  {
140  ERR("RpcBindingFree returned 0x%x\n", status);
141  }
142 }
143 
144 
145 DWORD
147 {
148  TRACE("ScmRpcStatusToWinError(%lx)\n",
149  Status);
150 
151  switch (Status)
152  {
156  return ERROR_INVALID_HANDLE;
157 
161 
163  return ERROR_INVALID_ADDRESS;
164 
165  default:
166  return (DWORD)Status;
167  }
168 }
169 
170 
171 static
172 DWORD
174  _In_ PVOID ContextHandle,
175  _In_ PCWSTR pClearTextPassword,
176  _Out_ PBYTE *pEncryptedPassword,
177  _Out_ PDWORD pEncryptedPasswordSize)
178 {
179  struct ustring inData, keyData, outData;
180  BYTE SessionKey[16];
181  PBYTE pBuffer;
183 
184  /* Get the session key */
185  Status = SystemFunction028(ContextHandle,
186  SessionKey);
187  if (!NT_SUCCESS(Status))
188  {
189  ERR("SystemFunction028 failed (Status 0x%08lx)\n", Status);
191  }
192 
193  inData.Length = (wcslen(pClearTextPassword) + 1) * sizeof(WCHAR);
194  inData.MaximumLength = inData.Length;
195  inData.Buffer = (unsigned char *)pClearTextPassword;
196 
197  keyData.Length = sizeof(SessionKey);
198  keyData.MaximumLength = keyData.Length;
199  keyData.Buffer = SessionKey;
200 
201  outData.Length = 0;
202  outData.MaximumLength = 0;
203  outData.Buffer = NULL;
204 
205  /* Get the required buffer size */
206  Status = SystemFunction004(&inData,
207  &keyData,
208  &outData);
210  {
211  ERR("SystemFunction004 failed (Status 0x%08lx)\n", Status);
213  }
214 
215  /* Allocate a buffer for the encrypted password */
216  pBuffer = HeapAlloc(GetProcessHeap(), 0, outData.Length);
217  if (pBuffer == NULL)
218  return ERROR_OUTOFMEMORY;
219 
220  outData.MaximumLength = outData.Length;
221  outData.Buffer = pBuffer;
222 
223  /* Encrypt the password */
224  Status = SystemFunction004(&inData,
225  &keyData,
226  &outData);
227  if (!NT_SUCCESS(Status))
228  {
229  ERR("SystemFunction004 failed (Status 0x%08lx)\n", Status);
232  }
233 
234  *pEncryptedPassword = outData.Buffer;
235  *pEncryptedPasswordSize = outData.Length;
236 
237  return ERROR_SUCCESS;
238 }
239 
240 
241 /**********************************************************************
242  * ChangeServiceConfig2A
243  *
244  * @implemented
245  */
246 BOOL WINAPI
247 ChangeServiceConfig2A(SC_HANDLE hService,
249  LPVOID lpInfo)
250 {
252  DWORD dwError;
253 
254  TRACE("ChangeServiceConfig2A(%p %lu %p)\n",
255  hService, dwInfoLevel, lpInfo);
256 
257  if (lpInfo == NULL) return TRUE;
258 
259  /* Fill relevant field of the Info structure */
260  Info.dwInfoLevel = dwInfoLevel;
261  switch (dwInfoLevel)
262  {
264  Info.psd = lpInfo;
265  break;
266 
268  Info.psfa = lpInfo;
269  break;
270 
271  default:
272  WARN("Unknown info level 0x%lx\n", dwInfoLevel);
274  return FALSE;
275  }
276 
278  {
279  dwError = RChangeServiceConfig2A((SC_RPC_HANDLE)hService,
280  Info);
281  }
283  {
285  }
286  RpcEndExcept;
287 
288  if (dwError != ERROR_SUCCESS)
289  {
290  TRACE("RChangeServiceConfig2A() failed (Error %lu)\n", dwError);
291  SetLastError(dwError);
292  return FALSE;
293  }
294 
295  return TRUE;
296 }
297 
298 
299 /**********************************************************************
300  * ChangeServiceConfig2W
301  *
302  * @implemented
303  */
304 BOOL WINAPI
305 ChangeServiceConfig2W(SC_HANDLE hService,
307  LPVOID lpInfo)
308 {
310  DWORD dwError;
311 
312  TRACE("ChangeServiceConfig2W(%p %lu %p)\n",
313  hService, dwInfoLevel, lpInfo);
314 
315  if (lpInfo == NULL) return TRUE;
316 
317  /* Fill relevant field of the Info structure */
318  Info.dwInfoLevel = dwInfoLevel;
319  switch (dwInfoLevel)
320  {
322  Info.psd = lpInfo;
323  break;
324 
326  Info.psfa = lpInfo;
327  break;
328 
329  default:
330  WARN("Unknown info level 0x%lx\n", dwInfoLevel);
332  return FALSE;
333  }
334 
336  {
337  dwError = RChangeServiceConfig2W((SC_RPC_HANDLE)hService,
338  Info);
339  }
341  {
343  }
344  RpcEndExcept;
345 
346  if (dwError != ERROR_SUCCESS)
347  {
348  TRACE("RChangeServiceConfig2W() failed (Error %lu)\n", dwError);
349  SetLastError(dwError);
350  return FALSE;
351  }
352 
353  return TRUE;
354 }
355 
356 
357 /**********************************************************************
358  * ChangeServiceConfigA
359  *
360  * @implemented
361  */
362 BOOL WINAPI
363 ChangeServiceConfigA(SC_HANDLE hService,
364  DWORD dwServiceType,
365  DWORD dwStartType,
366  DWORD dwErrorControl,
367  LPCSTR lpBinaryPathName,
368  LPCSTR lpLoadOrderGroup,
369  LPDWORD lpdwTagId,
370  LPCSTR lpDependencies,
371  LPCSTR lpServiceStartName,
372  LPCSTR lpPassword,
374 {
375  DWORD dwError;
376  DWORD dwDependenciesLength = 0;
377  SIZE_T cchLength;
378  LPCSTR lpStr;
379  DWORD dwPasswordSize = 0;
380  LPWSTR lpPasswordW = NULL;
381  LPBYTE lpEncryptedPassword = NULL;
382 
383  TRACE("ChangeServiceConfigA(%p %lu %lu %lu %s %s %p %s %s %s %s)\n",
384  hService, dwServiceType, dwStartType, dwErrorControl, debugstr_a(lpBinaryPathName),
385  debugstr_a(lpLoadOrderGroup), lpdwTagId, debugstr_a(lpDependencies),
386  debugstr_a(lpServiceStartName), debugstr_a(lpPassword), debugstr_a(lpDisplayName));
387 
388  /* Calculate the Dependencies length*/
389  if (lpDependencies != NULL)
390  {
391  lpStr = lpDependencies;
392  while (*lpStr)
393  {
394  cchLength = strlen(lpStr) + 1;
395  dwDependenciesLength += (DWORD)cchLength;
396  lpStr = lpStr + cchLength;
397  }
398  dwDependenciesLength++;
399  }
400 
401  if (lpPassword != NULL)
402  {
403  /* Convert the password to unicode */
404  lpPasswordW = HeapAlloc(GetProcessHeap(),
406  (strlen(lpPassword) + 1) * sizeof(WCHAR));
407  if (lpPasswordW == NULL)
408  {
410  return FALSE;
411  }
412 
414  0,
415  lpPassword,
416  -1,
417  lpPasswordW,
418  (int)(strlen(lpPassword) + 1));
419 
420  /* Encrypt the unicode password */
421  dwError = ScmEncryptPassword(hService,
422  lpPasswordW,
423  &lpEncryptedPassword,
424  &dwPasswordSize);
425  if (dwError != ERROR_SUCCESS)
426  goto done;
427  }
428 
430  {
431  dwError = RChangeServiceConfigA((SC_RPC_HANDLE)hService,
432  dwServiceType,
433  dwStartType,
434  dwErrorControl,
435  (LPSTR)lpBinaryPathName,
436  (LPSTR)lpLoadOrderGroup,
437  lpdwTagId,
438  (LPBYTE)lpDependencies,
439  dwDependenciesLength,
440  (LPSTR)lpServiceStartName,
441  lpEncryptedPassword,
442  dwPasswordSize,
444  }
446  {
448  }
449  RpcEndExcept;
450 
451 done:
452  if (lpPasswordW != NULL)
453  {
454  /* Wipe and release the password buffers */
455  SecureZeroMemory(lpPasswordW, (wcslen(lpPasswordW) + 1) * sizeof(WCHAR));
456  HeapFree(GetProcessHeap(), 0, lpPasswordW);
457 
458  if (lpEncryptedPassword != NULL)
459  {
460  SecureZeroMemory(lpEncryptedPassword, dwPasswordSize);
461  HeapFree(GetProcessHeap(), 0, lpEncryptedPassword);
462  }
463  }
464 
465  if (dwError != ERROR_SUCCESS)
466  {
467  TRACE("RChangeServiceConfigA() failed (Error %lu)\n", dwError);
468  SetLastError(dwError);
469  return FALSE;
470  }
471 
472  return TRUE;
473 }
474 
475 
476 /**********************************************************************
477  * ChangeServiceConfigW
478  *
479  * @implemented
480  */
481 BOOL WINAPI
482 ChangeServiceConfigW(SC_HANDLE hService,
483  DWORD dwServiceType,
484  DWORD dwStartType,
485  DWORD dwErrorControl,
486  LPCWSTR lpBinaryPathName,
487  LPCWSTR lpLoadOrderGroup,
488  LPDWORD lpdwTagId,
489  LPCWSTR lpDependencies,
490  LPCWSTR lpServiceStartName,
491  LPCWSTR lpPassword,
493 {
494  DWORD dwError;
495  DWORD dwDependenciesLength = 0;
496  SIZE_T cchLength;
497  LPCWSTR lpStr;
498  DWORD dwPasswordSize = 0;
499  LPBYTE lpEncryptedPassword = NULL;
500 
501  TRACE("ChangeServiceConfigW(%p %lu %lu %lu %s %s %p %s %s %s %s)\n",
502  hService, dwServiceType, dwStartType, dwErrorControl, debugstr_w(lpBinaryPathName),
503  debugstr_w(lpLoadOrderGroup), lpdwTagId, debugstr_w(lpDependencies),
504  debugstr_w(lpServiceStartName), debugstr_w(lpPassword), debugstr_w(lpDisplayName));
505 
506  /* Calculate the Dependencies length*/
507  if (lpDependencies != NULL)
508  {
509  lpStr = lpDependencies;
510  while (*lpStr)
511  {
512  cchLength = wcslen(lpStr) + 1;
513  dwDependenciesLength += (DWORD)cchLength;
514  lpStr = lpStr + cchLength;
515  }
516  dwDependenciesLength++;
517  dwDependenciesLength *= sizeof(WCHAR);
518  }
519 
520  if (lpPassword != NULL)
521  {
522  dwError = ScmEncryptPassword(hService,
523  lpPassword,
524  &lpEncryptedPassword,
525  &dwPasswordSize);
526  if (dwError != ERROR_SUCCESS)
527  {
528  ERR("ScmEncryptPassword failed (Error %lu)\n", dwError);
529  goto done;
530  }
531  }
532 
534  {
535  dwError = RChangeServiceConfigW((SC_RPC_HANDLE)hService,
536  dwServiceType,
537  dwStartType,
538  dwErrorControl,
539  (LPWSTR)lpBinaryPathName,
540  (LPWSTR)lpLoadOrderGroup,
541  lpdwTagId,
542  (LPBYTE)lpDependencies,
543  dwDependenciesLength,
544  (LPWSTR)lpServiceStartName,
545  lpEncryptedPassword,
546  dwPasswordSize,
548  }
550  {
552  }
553  RpcEndExcept;
554 
555 done:
556  if (lpEncryptedPassword != NULL)
557  {
558  /* Wipe and release the password buffer */
559  SecureZeroMemory(lpEncryptedPassword, dwPasswordSize);
560  HeapFree(GetProcessHeap(), 0, lpEncryptedPassword);
561  }
562 
563  if (dwError != ERROR_SUCCESS)
564  {
565  TRACE("RChangeServiceConfigW() failed (Error %lu)\n", dwError);
566  SetLastError(dwError);
567  return FALSE;
568  }
569 
570  return TRUE;
571 }
572 
573 
574 /**********************************************************************
575  * CloseServiceHandle
576  *
577  * @implemented
578  */
579 BOOL WINAPI
580 CloseServiceHandle(SC_HANDLE hSCObject)
581 {
582  DWORD dwError;
583 
584  TRACE("CloseServiceHandle(%p)\n",
585  hSCObject);
586 
587  if (!hSCObject)
588  {
590  return FALSE;
591  }
592 
594  {
595  dwError = RCloseServiceHandle((LPSC_RPC_HANDLE)&hSCObject);
596  }
598  {
600  }
601  RpcEndExcept;
602 
603  if (dwError)
604  {
605  TRACE("RCloseServiceHandle() failed (Error %lu)\n", dwError);
606  SetLastError(dwError);
607  return FALSE;
608  }
609 
610  TRACE("CloseServiceHandle() done\n");
611 
612  return TRUE;
613 }
614 
615 
616 /**********************************************************************
617  * ControlService
618  *
619  * @implemented
620  */
621 BOOL WINAPI
622 ControlService(SC_HANDLE hService,
623  DWORD dwControl,
624  LPSERVICE_STATUS lpServiceStatus)
625 {
626  DWORD dwError;
627 
628  TRACE("ControlService(%p %lu %p)\n",
629  hService, dwControl, lpServiceStatus);
630 
632  {
633  dwError = RControlService((SC_RPC_HANDLE)hService,
634  dwControl,
635  lpServiceStatus);
636  }
638  {
640  }
641  RpcEndExcept;
642 
643  if (dwError != ERROR_SUCCESS)
644  {
645  TRACE("RControlService() failed (Error %lu)\n", dwError);
646  SetLastError(dwError);
647  return FALSE;
648  }
649 
650  TRACE("ControlService() done\n");
651 
652  return TRUE;
653 }
654 
655 
656 /**********************************************************************
657  * ControlServiceEx
658  *
659  * @unimplemented
660  */
661 BOOL WINAPI
662 ControlServiceEx(IN SC_HANDLE hService,
663  IN DWORD dwControl,
665  IN OUT PVOID pControlParams)
666 {
667  FIXME("ControlServiceEx(%p %lu %lu %p)\n",
668  hService, dwControl, dwInfoLevel, pControlParams);
670  return FALSE;
671 }
672 
673 
674 /**********************************************************************
675  * CreateServiceA
676  *
677  * @implemented
678  */
679 SC_HANDLE WINAPI
681  LPCSTR lpServiceName,
683  DWORD dwDesiredAccess,
684  DWORD dwServiceType,
685  DWORD dwStartType,
686  DWORD dwErrorControl,
687  LPCSTR lpBinaryPathName,
688  LPCSTR lpLoadOrderGroup,
689  LPDWORD lpdwTagId,
690  LPCSTR lpDependencies,
691  LPCSTR lpServiceStartName,
692  LPCSTR lpPassword)
693 {
694  SC_HANDLE hService = NULL;
695  DWORD dwDependenciesLength = 0;
696  DWORD dwError;
697  SIZE_T cchLength;
698  LPCSTR lpStr;
699  DWORD dwPasswordSize = 0;
700  LPWSTR lpPasswordW = NULL;
701  LPBYTE lpEncryptedPassword = NULL;
702 
703  TRACE("CreateServiceA(%p %s %s %lx %lu %lu %lu %s %s %p %s %s %s)\n",
704  hSCManager, debugstr_a(lpServiceName), debugstr_a(lpDisplayName),
705  dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
706  debugstr_a(lpBinaryPathName), debugstr_a(lpLoadOrderGroup), lpdwTagId,
707  debugstr_a(lpDependencies), debugstr_a(lpServiceStartName), debugstr_a(lpPassword));
708 
709  if (!hSCManager)
710  {
712  return NULL;
713  }
714 
715  /* Calculate the Dependencies length */
716  if (lpDependencies != NULL)
717  {
718  lpStr = lpDependencies;
719  while (*lpStr)
720  {
721  cchLength = strlen(lpStr) + 1;
722  dwDependenciesLength += (DWORD)cchLength;
723  lpStr = lpStr + cchLength;
724  }
725  dwDependenciesLength++;
726  }
727 
728  if (lpPassword != NULL)
729  {
730  /* Convert the password to unicode */
731  lpPasswordW = HeapAlloc(GetProcessHeap(),
733  (strlen(lpPassword) + 1) * sizeof(WCHAR));
734  if (lpPasswordW == NULL)
735  {
737  return FALSE;
738  }
739 
741  0,
742  lpPassword,
743  -1,
744  lpPasswordW,
745  (int)(strlen(lpPassword) + 1));
746 
747  /* Encrypt the password */
748  dwError = ScmEncryptPassword(hSCManager,
749  lpPasswordW,
750  &lpEncryptedPassword,
751  &dwPasswordSize);
752  if (dwError != ERROR_SUCCESS)
753  goto done;
754  }
755 
757  {
759  (LPSTR)lpServiceName,
761  dwDesiredAccess,
762  dwServiceType,
763  dwStartType,
764  dwErrorControl,
765  (LPSTR)lpBinaryPathName,
766  (LPSTR)lpLoadOrderGroup,
767  lpdwTagId,
768  (LPBYTE)lpDependencies,
769  dwDependenciesLength,
770  (LPSTR)lpServiceStartName,
771  lpEncryptedPassword,
772  dwPasswordSize,
773  (SC_RPC_HANDLE *)&hService);
774  }
776  {
778  }
779  RpcEndExcept;
780 
781 done:
782  if (lpPasswordW != NULL)
783  {
784  /* Wipe and release the password buffers */
785  SecureZeroMemory(lpPasswordW, (wcslen(lpPasswordW) + 1) * sizeof(WCHAR));
786  HeapFree(GetProcessHeap(), 0, lpPasswordW);
787 
788  if (lpEncryptedPassword != NULL)
789  {
790  SecureZeroMemory(lpEncryptedPassword, dwPasswordSize);
791  HeapFree(GetProcessHeap(), 0, lpEncryptedPassword);
792  }
793  }
794 
795  SetLastError(dwError);
796  if (dwError != ERROR_SUCCESS)
797  {
798  TRACE("RCreateServiceA() failed (Error %lu)\n", dwError);
799  return NULL;
800  }
801 
802  return hService;
803 }
804 
805 
806 /**********************************************************************
807  * CreateServiceW
808  *
809  * @implemented
810  */
811 SC_HANDLE WINAPI
813  LPCWSTR lpServiceName,
815  DWORD dwDesiredAccess,
816  DWORD dwServiceType,
817  DWORD dwStartType,
818  DWORD dwErrorControl,
819  LPCWSTR lpBinaryPathName,
820  LPCWSTR lpLoadOrderGroup,
821  LPDWORD lpdwTagId,
822  LPCWSTR lpDependencies,
823  LPCWSTR lpServiceStartName,
824  LPCWSTR lpPassword)
825 {
826  SC_HANDLE hService = NULL;
827  DWORD dwDependenciesLength = 0;
828  DWORD dwError;
829  SIZE_T cchLength;
830  LPCWSTR lpStr;
831  DWORD dwPasswordSize = 0;
832  LPBYTE lpEncryptedPassword = NULL;
833 
834  TRACE("CreateServiceW(%p %s %s %lx %lu %lu %lu %s %s %p %s %s %s)\n",
835  hSCManager, debugstr_w(lpServiceName), debugstr_w(lpDisplayName),
836  dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
837  debugstr_w(lpBinaryPathName), debugstr_w(lpLoadOrderGroup), lpdwTagId,
838  debugstr_w(lpDependencies), debugstr_w(lpServiceStartName), debugstr_w(lpPassword));
839 
840  if (!hSCManager)
841  {
843  return NULL;
844  }
845 
846  /* Calculate the Dependencies length */
847  if (lpDependencies != NULL)
848  {
849  lpStr = lpDependencies;
850  while (*lpStr)
851  {
852  cchLength = wcslen(lpStr) + 1;
853  dwDependenciesLength += (DWORD)cchLength;
854  lpStr = lpStr + cchLength;
855  }
856  dwDependenciesLength++;
857  dwDependenciesLength *= sizeof(WCHAR);
858  }
859 
860  if (lpPassword != NULL)
861  {
862  /* Encrypt the password */
863  dwError = ScmEncryptPassword(hSCManager,
864  lpPassword,
865  &lpEncryptedPassword,
866  &dwPasswordSize);
867  if (dwError != ERROR_SUCCESS)
868  goto done;
869  }
870 
872  {
874  lpServiceName,
876  dwDesiredAccess,
877  dwServiceType,
878  dwStartType,
879  dwErrorControl,
880  lpBinaryPathName,
881  lpLoadOrderGroup,
882  lpdwTagId,
883  (LPBYTE)lpDependencies,
884  dwDependenciesLength,
885  lpServiceStartName,
886  lpEncryptedPassword,
887  dwPasswordSize,
888  (SC_RPC_HANDLE *)&hService);
889  }
891  {
893  }
894  RpcEndExcept;
895 
896 done:
897  if (lpEncryptedPassword != NULL)
898  {
899  /* Wipe and release the password buffers */
900  SecureZeroMemory(lpEncryptedPassword, dwPasswordSize);
901  HeapFree(GetProcessHeap(), 0, lpEncryptedPassword);
902  }
903 
904  SetLastError(dwError);
905  if (dwError != ERROR_SUCCESS)
906  {
907  TRACE("RCreateServiceW() failed (Error %lu)\n", dwError);
908  return NULL;
909  }
910 
911  return hService;
912 }
913 
914 
915 /**********************************************************************
916  * DeleteService
917  *
918  * @implemented
919  */
920 BOOL WINAPI
921 DeleteService(SC_HANDLE hService)
922 {
923  DWORD dwError;
924 
925  TRACE("DeleteService(%p)\n",
926  hService);
927 
929  {
930  dwError = RDeleteService((SC_RPC_HANDLE)hService);
931  }
933  {
935  }
936  RpcEndExcept;
937 
938  if (dwError != ERROR_SUCCESS)
939  {
940  TRACE("RDeleteService() failed (Error %lu)\n", dwError);
941  SetLastError(dwError);
942  return FALSE;
943  }
944 
945  return TRUE;
946 }
947 
948 
949 /**********************************************************************
950  * EnumDependentServicesA
951  *
952  * @implemented
953  */
954 BOOL WINAPI
955 EnumDependentServicesA(SC_HANDLE hService,
956  DWORD dwServiceState,
957  LPENUM_SERVICE_STATUSA lpServices,
960  LPDWORD lpServicesReturned)
961 {
963  LPENUM_SERVICE_STATUSA lpStatusPtr;
964  DWORD dwBufferSize;
965  DWORD dwError;
966  DWORD dwCount;
967 
968  TRACE("EnumDependentServicesA(%p %lu %p %lu %p %p)\n",
969  hService, dwServiceState, lpServices, cbBufSize,
970  pcbBytesNeeded, lpServicesReturned);
971 
972  if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSA))
973  {
974  lpStatusPtr = &ServiceStatus;
975  dwBufferSize = sizeof(ENUM_SERVICE_STATUSA);
976  }
977  else
978  {
979  lpStatusPtr = lpServices;
980  dwBufferSize = cbBufSize;
981  }
982 
984  {
985  dwError = REnumDependentServicesA((SC_RPC_HANDLE)hService,
986  dwServiceState,
987  (LPBYTE)lpStatusPtr,
988  dwBufferSize,
990  lpServicesReturned);
991  }
993  {
995  }
996  RpcEndExcept;
997 
998  if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
999  {
1000  for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1001  {
1002  if (lpStatusPtr->lpServiceName)
1003  lpStatusPtr->lpServiceName =
1004  (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1005 
1006  if (lpStatusPtr->lpDisplayName)
1007  lpStatusPtr->lpDisplayName =
1008  (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1009 
1010  lpStatusPtr++;
1011  }
1012  }
1013 
1014  if (dwError != ERROR_SUCCESS)
1015  {
1016  TRACE("REnumDependentServicesA() failed (Error %lu)\n", dwError);
1017  SetLastError(dwError);
1018  return FALSE;
1019  }
1020 
1021  TRACE("EnumDependentServicesA() done\n");
1022 
1023  return TRUE;
1024 }
1025 
1026 
1027 /**********************************************************************
1028  * EnumDependentServicesW
1029  *
1030  * @implemented
1031  */
1032 BOOL WINAPI
1033 EnumDependentServicesW(SC_HANDLE hService,
1034  DWORD dwServiceState,
1035  LPENUM_SERVICE_STATUSW lpServices,
1036  DWORD cbBufSize,
1038  LPDWORD lpServicesReturned)
1039 {
1041  LPENUM_SERVICE_STATUSW lpStatusPtr;
1042  DWORD dwBufferSize;
1043  DWORD dwError;
1044  DWORD dwCount;
1045 
1046  TRACE("EnumDependentServicesW(%p %lu %p %lu %p %p)\n",
1047  hService, dwServiceState, lpServices, cbBufSize,
1048  pcbBytesNeeded, lpServicesReturned);
1049 
1050  if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSW))
1051  {
1052  lpStatusPtr = &ServiceStatus;
1053  dwBufferSize = sizeof(ENUM_SERVICE_STATUSW);
1054  }
1055  else
1056  {
1057  lpStatusPtr = lpServices;
1058  dwBufferSize = cbBufSize;
1059  }
1060 
1061  RpcTryExcept
1062  {
1063  dwError = REnumDependentServicesW((SC_RPC_HANDLE)hService,
1064  dwServiceState,
1065  (LPBYTE)lpStatusPtr,
1066  dwBufferSize,
1068  lpServicesReturned);
1069  }
1071  {
1073  }
1074  RpcEndExcept;
1075 
1076  if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1077  {
1078  for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1079  {
1080  if (lpStatusPtr->lpServiceName)
1081  lpStatusPtr->lpServiceName =
1082  (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1083 
1084  if (lpStatusPtr->lpDisplayName)
1085  lpStatusPtr->lpDisplayName =
1086  (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1087 
1088  lpStatusPtr++;
1089  }
1090  }
1091 
1092  if (dwError != ERROR_SUCCESS)
1093  {
1094  TRACE("REnumDependentServicesW() failed (Error %lu)\n", dwError);
1095  SetLastError(dwError);
1096  return FALSE;
1097  }
1098 
1099  TRACE("EnumDependentServicesW() done\n");
1100 
1101  return TRUE;
1102 }
1103 
1104 
1105 /**********************************************************************
1106  * EnumServiceGroupW
1107  *
1108  * @implemented
1109  */
1110 BOOL WINAPI
1112  DWORD dwServiceType,
1113  DWORD dwServiceState,
1114  LPENUM_SERVICE_STATUSW lpServices,
1115  DWORD cbBufSize,
1117  LPDWORD lpServicesReturned,
1118  LPDWORD lpResumeHandle,
1119  LPCWSTR lpGroup)
1120 {
1122  LPENUM_SERVICE_STATUSW lpStatusPtr;
1123  DWORD dwBufferSize;
1124  DWORD dwError;
1125  DWORD dwCount;
1126 
1127  TRACE("EnumServiceGroupW(%p %lu %lu %p %lu %p %p %p %s)\n",
1128  hSCManager, dwServiceType, dwServiceState, lpServices,
1129  cbBufSize, pcbBytesNeeded, lpServicesReturned,
1130  lpResumeHandle, debugstr_w(lpGroup));
1131 
1132  if (!hSCManager)
1133  {
1135  return FALSE;
1136  }
1137 
1138  if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
1139  {
1141  return FALSE;
1142  }
1143 
1144  if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSW))
1145  {
1146  lpStatusPtr = &ServiceStatus;
1147  dwBufferSize = sizeof(ENUM_SERVICE_STATUSW);
1148  }
1149  else
1150  {
1151  lpStatusPtr = lpServices;
1152  dwBufferSize = cbBufSize;
1153  }
1154 
1155  RpcTryExcept
1156  {
1157  if (lpGroup == NULL)
1158  {
1160  dwServiceType,
1161  dwServiceState,
1162  (LPBYTE)lpStatusPtr,
1163  dwBufferSize,
1165  lpServicesReturned,
1166  lpResumeHandle);
1167  }
1168  else
1169  {
1171  dwServiceType,
1172  dwServiceState,
1173  (LPBYTE)lpStatusPtr,
1174  dwBufferSize,
1176  lpServicesReturned,
1177  lpResumeHandle,
1178  lpGroup);
1179  }
1180  }
1182  {
1184  }
1185  RpcEndExcept;
1186 
1187  if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1188  {
1189  for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1190  {
1191  if (lpStatusPtr->lpServiceName)
1192  lpStatusPtr->lpServiceName =
1193  (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1194 
1195  if (lpStatusPtr->lpDisplayName)
1196  lpStatusPtr->lpDisplayName =
1197  (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1198 
1199  lpStatusPtr++;
1200  }
1201  }
1202 
1203  if (dwError != ERROR_SUCCESS)
1204  {
1205  TRACE("REnumServiceGroupW() failed (Error %lu)\n", dwError);
1206  SetLastError(dwError);
1207  return FALSE;
1208  }
1209 
1210  TRACE("EnumServiceGroupW() done\n");
1211 
1212  return TRUE;
1213 }
1214 
1215 
1216 /**********************************************************************
1217  * EnumServicesStatusA
1218  *
1219  * @implemented
1220  */
1221 BOOL WINAPI
1223  DWORD dwServiceType,
1224  DWORD dwServiceState,
1225  LPENUM_SERVICE_STATUSA lpServices,
1226  DWORD cbBufSize,
1228  LPDWORD lpServicesReturned,
1229  LPDWORD lpResumeHandle)
1230 {
1232  LPENUM_SERVICE_STATUSA lpStatusPtr;
1233  DWORD dwBufferSize;
1234  DWORD dwError;
1235  DWORD dwCount;
1236 
1237  TRACE("EnumServicesStatusA(%p %lu %lu %p %lu %p %p %p)\n",
1238  hSCManager, dwServiceType, dwServiceState, lpServices,
1239  cbBufSize, pcbBytesNeeded, lpServicesReturned, lpResumeHandle);
1240 
1241  if (!hSCManager)
1242  {
1244  return FALSE;
1245  }
1246 
1247  if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
1248  {
1250  return FALSE;
1251  }
1252 
1253  if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSA))
1254  {
1255  lpStatusPtr = &ServiceStatus;
1256  dwBufferSize = sizeof(ENUM_SERVICE_STATUSA);
1257  }
1258  else
1259  {
1260  lpStatusPtr = lpServices;
1261  dwBufferSize = cbBufSize;
1262  }
1263 
1264  RpcTryExcept
1265  {
1267  dwServiceType,
1268  dwServiceState,
1269  (LPBYTE)lpStatusPtr,
1270  dwBufferSize,
1272  lpServicesReturned,
1273  lpResumeHandle);
1274  }
1276  {
1278  }
1279  RpcEndExcept;
1280 
1281  if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1282  {
1283  for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1284  {
1285  if (lpStatusPtr->lpServiceName)
1286  lpStatusPtr->lpServiceName =
1287  (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1288 
1289  if (lpStatusPtr->lpDisplayName)
1290  lpStatusPtr->lpDisplayName =
1291  (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1292 
1293  lpStatusPtr++;
1294  }
1295  }
1296 
1297  if (dwError != ERROR_SUCCESS)
1298  {
1299  TRACE("REnumServicesStatusA() failed (Error %lu)\n", dwError);
1300  SetLastError(dwError);
1301  return FALSE;
1302  }
1303 
1304  TRACE("EnumServicesStatusA() done\n");
1305 
1306  return TRUE;
1307 }
1308 
1309 
1310 /**********************************************************************
1311  * EnumServicesStatusW
1312  *
1313  * @implemented
1314  */
1315 BOOL WINAPI
1317  DWORD dwServiceType,
1318  DWORD dwServiceState,
1319  LPENUM_SERVICE_STATUSW lpServices,
1320  DWORD cbBufSize,
1322  LPDWORD lpServicesReturned,
1323  LPDWORD lpResumeHandle)
1324 {
1326  LPENUM_SERVICE_STATUSW lpStatusPtr;
1327  DWORD dwBufferSize;
1328  DWORD dwError;
1329  DWORD dwCount;
1330 
1331  TRACE("EnumServicesStatusW(%p %lu %lu %p %lu %p %p %p)\n",
1332  hSCManager, dwServiceType, dwServiceState, lpServices,
1333  cbBufSize, pcbBytesNeeded, lpServicesReturned, lpResumeHandle);
1334 
1335  if (!hSCManager)
1336  {
1338  return FALSE;
1339  }
1340 
1341  if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
1342  {
1344  return FALSE;
1345  }
1346 
1347  if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSW))
1348  {
1349  lpStatusPtr = &ServiceStatus;
1350  dwBufferSize = sizeof(ENUM_SERVICE_STATUSW);
1351  }
1352  else
1353  {
1354  lpStatusPtr = lpServices;
1355  dwBufferSize = cbBufSize;
1356  }
1357 
1358  RpcTryExcept
1359  {
1361  dwServiceType,
1362  dwServiceState,
1363  (LPBYTE)lpStatusPtr,
1364  dwBufferSize,
1366  lpServicesReturned,
1367  lpResumeHandle);
1368  }
1370  {
1372  }
1373  RpcEndExcept;
1374 
1375  if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1376  {
1377  for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1378  {
1379  if (lpStatusPtr->lpServiceName)
1380  lpStatusPtr->lpServiceName =
1381  (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1382 
1383  if (lpStatusPtr->lpDisplayName)
1384  lpStatusPtr->lpDisplayName =
1385  (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1386 
1387  lpStatusPtr++;
1388  }
1389  }
1390 
1391  if (dwError != ERROR_SUCCESS)
1392  {
1393  TRACE("REnumServicesStatusW() failed (Error %lu)\n", dwError);
1394  SetLastError(dwError);
1395  return FALSE;
1396  }
1397 
1398  TRACE("EnumServicesStatusW() done\n");
1399 
1400  return TRUE;
1401 }
1402 
1403 
1404 /**********************************************************************
1405  * EnumServicesStatusExA
1406  *
1407  * @implemented
1408  */
1409 BOOL WINAPI
1411  SC_ENUM_TYPE InfoLevel,
1412  DWORD dwServiceType,
1413  DWORD dwServiceState,
1414  LPBYTE lpServices,
1415  DWORD cbBufSize,
1417  LPDWORD lpServicesReturned,
1418  LPDWORD lpResumeHandle,
1419  LPCSTR pszGroupName)
1420 {
1422  LPENUM_SERVICE_STATUS_PROCESSA lpStatusPtr;
1423  DWORD dwBufferSize;
1424  DWORD dwError;
1425  DWORD dwCount;
1426 
1427  TRACE("EnumServicesStatusExA(%p %lu %lu %p %lu %p %p %p %s)\n",
1428  hSCManager, dwServiceType, dwServiceState, lpServices,
1429  cbBufSize, pcbBytesNeeded, lpServicesReturned, lpResumeHandle,
1430  debugstr_a(pszGroupName));
1431 
1432  if (InfoLevel != SC_ENUM_PROCESS_INFO)
1433  {
1435  return FALSE;
1436  }
1437 
1438  if (!hSCManager)
1439  {
1441  return FALSE;
1442  }
1443 
1444  if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
1445  {
1447  return FALSE;
1448  }
1449 
1450  if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUS_PROCESSA))
1451  {
1452  lpStatusPtr = &ServiceStatus;
1453  dwBufferSize = sizeof(ENUM_SERVICE_STATUS_PROCESSA);
1454  }
1455  else
1456  {
1457  lpStatusPtr = (LPENUM_SERVICE_STATUS_PROCESSA)lpServices;
1458  dwBufferSize = cbBufSize;
1459  }
1460 
1461  RpcTryExcept
1462  {
1464  InfoLevel,
1465  dwServiceType,
1466  dwServiceState,
1467  (LPBYTE)lpStatusPtr,
1468  dwBufferSize,
1470  lpServicesReturned,
1471  lpResumeHandle,
1472  (LPSTR)pszGroupName);
1473  }
1475  {
1477  }
1478  RpcEndExcept;
1479 
1480  if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1481  {
1482  if (InfoLevel == SC_ENUM_PROCESS_INFO)
1483  {
1484  for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1485  {
1486  if (lpStatusPtr->lpServiceName)
1487  lpStatusPtr->lpServiceName =
1488  (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1489 
1490  if (lpStatusPtr->lpDisplayName)
1491  lpStatusPtr->lpDisplayName =
1492  (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1493 
1494  lpStatusPtr++;
1495  }
1496  }
1497  }
1498 
1499  if (dwError != ERROR_SUCCESS)
1500  {
1501  TRACE("REnumServicesStatusExA() failed (Error %lu)\n", dwError);
1502  SetLastError(dwError);
1503  return FALSE;
1504  }
1505 
1506  TRACE("EnumServicesStatusExA() done\n");
1507 
1508  return TRUE;
1509 }
1510 
1511 
1512 /**********************************************************************
1513  * EnumServicesStatusExW
1514  *
1515  * @implemented
1516  */
1517 BOOL WINAPI
1519  SC_ENUM_TYPE InfoLevel,
1520  DWORD dwServiceType,
1521  DWORD dwServiceState,
1522  LPBYTE lpServices,
1523  DWORD cbBufSize,
1525  LPDWORD lpServicesReturned,
1526  LPDWORD lpResumeHandle,
1527  LPCWSTR pszGroupName)
1528 {
1530  LPENUM_SERVICE_STATUS_PROCESSW lpStatusPtr;
1531  DWORD dwBufferSize;
1532  DWORD dwError;
1533  DWORD dwCount;
1534 
1535  TRACE("EnumServicesStatusExW(%p %lu %lu %p %lu %p %p %p %s)\n",
1536  hSCManager, dwServiceType, dwServiceState, lpServices,
1537  cbBufSize, pcbBytesNeeded, lpServicesReturned, lpResumeHandle,
1538  debugstr_w(pszGroupName));
1539 
1540  if (InfoLevel != SC_ENUM_PROCESS_INFO)
1541  {
1543  return FALSE;
1544  }
1545 
1546  if (!hSCManager)
1547  {
1549  return FALSE;
1550  }
1551 
1552  if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
1553  {
1555  return FALSE;
1556  }
1557 
1558  if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUS_PROCESSW))
1559  {
1560  lpStatusPtr = &ServiceStatus;
1561  dwBufferSize = sizeof(ENUM_SERVICE_STATUS_PROCESSW);
1562  }
1563  else
1564  {
1565  lpStatusPtr = (LPENUM_SERVICE_STATUS_PROCESSW)lpServices;
1566  dwBufferSize = cbBufSize;
1567  }
1568 
1569  RpcTryExcept
1570  {
1572  InfoLevel,
1573  dwServiceType,
1574  dwServiceState,
1575  (LPBYTE)lpStatusPtr,
1576  dwBufferSize,
1578  lpServicesReturned,
1579  lpResumeHandle,
1580  (LPWSTR)pszGroupName);
1581  }
1583  {
1585  }
1586  RpcEndExcept;
1587 
1588  if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1589  {
1590  if (InfoLevel == SC_ENUM_PROCESS_INFO)
1591  {
1592  for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1593  {
1594  if (lpStatusPtr->lpServiceName)
1595  lpStatusPtr->lpServiceName =
1596  (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1597 
1598  if (lpStatusPtr->lpDisplayName)
1599  lpStatusPtr->lpDisplayName =
1600  (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1601 
1602  lpStatusPtr++;
1603  }
1604  }
1605  }
1606 
1607  if (dwError != ERROR_SUCCESS)
1608  {
1609  TRACE("REnumServicesStatusExW() failed (Error %lu)\n", dwError);
1610  SetLastError(dwError);
1611  return FALSE;
1612  }
1613 
1614  TRACE("EnumServicesStatusExW() done\n");
1615 
1616  return TRUE;
1617 }
1618 
1619 
1620 /**********************************************************************
1621  * GetServiceDisplayNameA
1622  *
1623  * @implemented
1624  */
1625 BOOL WINAPI
1627  LPCSTR lpServiceName,
1629  LPDWORD lpcchBuffer)
1630 {
1631  DWORD dwError;
1633  CHAR szEmptyName[] = "";
1634 
1635  TRACE("GetServiceDisplayNameA(%p %s %p %p)\n",
1636  hSCManager, debugstr_a(lpServiceName), lpDisplayName, lpcchBuffer);
1637 
1638  if (!hSCManager)
1639  {
1641  return FALSE;
1642  }
1643 
1644  if (!lpDisplayName || *lpcchBuffer < sizeof(CHAR))
1645  {
1646  lpNameBuffer = szEmptyName;
1647  *lpcchBuffer = sizeof(CHAR);
1648  }
1649  else
1650  {
1652  }
1653 
1654  RpcTryExcept
1655  {
1657  lpServiceName,
1658  lpNameBuffer,
1659  lpcchBuffer);
1660  }
1662  {
1664  }
1665  RpcEndExcept;
1666 
1667  if (dwError != ERROR_SUCCESS)
1668  {
1669  TRACE("RGetServiceDisplayNameA() failed (Error %lu)\n", dwError);
1670  SetLastError(dwError);
1671  return FALSE;
1672  }
1673 
1674  return TRUE;
1675 }
1676 
1677 
1678 /**********************************************************************
1679  * GetServiceDisplayNameW
1680  *
1681  * @implemented
1682  */
1683 BOOL WINAPI
1685  LPCWSTR lpServiceName,
1687  LPDWORD lpcchBuffer)
1688 {
1689  DWORD dwError;
1691  WCHAR szEmptyName[] = L"";
1692 
1693  TRACE("GetServiceDisplayNameW(%p %s %p %p)\n",
1694  hSCManager, debugstr_w(lpServiceName), lpDisplayName, lpcchBuffer);
1695 
1696  if (!hSCManager)
1697  {
1699  return FALSE;
1700  }
1701 
1702  /*
1703  * NOTE: A size of 1 character would be enough, but tests show that
1704  * Windows returns 2 characters instead, certainly due to a WCHAR/bytes
1705  * mismatch in their code.
1706  */
1707  if (!lpDisplayName || *lpcchBuffer < sizeof(WCHAR))
1708  {
1709  lpNameBuffer = szEmptyName;
1710  *lpcchBuffer = sizeof(WCHAR);
1711  }
1712  else
1713  {
1715  }
1716 
1717  RpcTryExcept
1718  {
1720  lpServiceName,
1721  lpNameBuffer,
1722  lpcchBuffer);
1723  }
1725  {
1727  }
1728  RpcEndExcept;
1729 
1730  if (dwError != ERROR_SUCCESS)
1731  {
1732  TRACE("RGetServiceDisplayNameW() failed (Error %lu)\n", dwError);
1733  SetLastError(dwError);
1734  return FALSE;
1735  }
1736 
1737  return TRUE;
1738 }
1739 
1740 
1741 /**********************************************************************
1742  * GetServiceKeyNameA
1743  *
1744  * @implemented
1745  */
1746 BOOL WINAPI
1749  LPSTR lpServiceName,
1750  LPDWORD lpcchBuffer)
1751 {
1752  DWORD dwError;
1754  CHAR szEmptyName[] = "";
1755 
1756  TRACE("GetServiceKeyNameA(%p %s %p %p)\n",
1757  hSCManager, debugstr_a(lpDisplayName), lpServiceName, lpcchBuffer);
1758 
1759  if (!hSCManager)
1760  {
1762  return FALSE;
1763  }
1764 
1765  if (!lpServiceName || *lpcchBuffer < sizeof(CHAR))
1766  {
1767  lpNameBuffer = szEmptyName;
1768  *lpcchBuffer = sizeof(CHAR);
1769  }
1770  else
1771  {
1772  lpNameBuffer = lpServiceName;
1773  }
1774 
1775  RpcTryExcept
1776  {
1778  lpDisplayName,
1779  lpNameBuffer,
1780  lpcchBuffer);
1781  }
1783  {
1784  /* HACK: because of a problem with rpcrt4, rpcserver is hacked to return 6 for ERROR_SERVICE_DOES_NOT_EXIST */
1786  }
1787  RpcEndExcept;
1788 
1789  if (dwError != ERROR_SUCCESS)
1790  {
1791  TRACE("RGetServiceKeyNameA() failed (Error %lu)\n", dwError);
1792  SetLastError(dwError);
1793  return FALSE;
1794  }
1795 
1796  return TRUE;
1797 }
1798 
1799 
1800 /**********************************************************************
1801  * GetServiceKeyNameW
1802  *
1803  * @implemented
1804  */
1805 BOOL WINAPI
1808  LPWSTR lpServiceName,
1809  LPDWORD lpcchBuffer)
1810 {
1811  DWORD dwError;
1813  WCHAR szEmptyName[] = L"";
1814 
1815  TRACE("GetServiceKeyNameW(%p %s %p %p)\n",
1816  hSCManager, debugstr_w(lpDisplayName), lpServiceName, lpcchBuffer);
1817 
1818  if (!hSCManager)
1819  {
1821  return FALSE;
1822  }
1823 
1824  /*
1825  * NOTE: A size of 1 character would be enough, but tests show that
1826  * Windows returns 2 characters instead, certainly due to a WCHAR/bytes
1827  * mismatch in their code.
1828  */
1829  if (!lpServiceName || *lpcchBuffer < sizeof(WCHAR))
1830  {
1831  lpNameBuffer = szEmptyName;
1832  *lpcchBuffer = sizeof(WCHAR);
1833  }
1834  else
1835  {
1836  lpNameBuffer = lpServiceName;
1837  }
1838 
1839  RpcTryExcept
1840  {
1842  lpDisplayName,
1843  lpNameBuffer,
1844  lpcchBuffer);
1845  }
1847  {
1849  }
1850  RpcEndExcept;
1851 
1852  if (dwError != ERROR_SUCCESS)
1853  {
1854  TRACE("RGetServiceKeyNameW() failed (Error %lu)\n", dwError);
1855  SetLastError(dwError);
1856  return FALSE;
1857  }
1858 
1859  return TRUE;
1860 }
1861 
1862 
1863 /**********************************************************************
1864  * I_ScGetCurrentGroupStateW
1865  *
1866  * @implemented
1867  */
1868 DWORD WINAPI
1870  LPWSTR pszGroupName,
1871  LPDWORD pdwGroupState)
1872 {
1873  DWORD dwError;
1874 
1875  TRACE("I_ScGetCurrentGroupStateW(%p %s %p)\n",
1876  hSCManager, debugstr_w(pszGroupName), pdwGroupState);
1877 
1878  RpcTryExcept
1879  {
1881  pszGroupName,
1882  pdwGroupState);
1883  }
1885  {
1887  }
1888  RpcEndExcept
1889 
1890  if (dwError != ERROR_SUCCESS)
1891  {
1892  TRACE("RI_ScGetCurrentGroupStateW() failed (Error %lu)\n", dwError);
1893  SetLastError(dwError);
1894  }
1895 
1896  return dwError;
1897 }
1898 
1899 
1900 /**********************************************************************
1901  * LockServiceDatabase
1902  *
1903  * @implemented
1904  */
1907 {
1908  SC_LOCK hLock;
1909  DWORD dwError;
1910 
1911  TRACE("LockServiceDatabase(%p)\n",
1912  hSCManager);
1913 
1914  RpcTryExcept
1915  {
1917  (SC_RPC_LOCK *)&hLock);
1918  }
1920  {
1922  }
1923  RpcEndExcept;
1924 
1925  if (dwError != ERROR_SUCCESS)
1926  {
1927  TRACE("RLockServiceDatabase() failed (Error %lu)\n", dwError);
1928  SetLastError(dwError);
1929  return NULL;
1930  }
1931 
1932  TRACE("hLock = %p\n", hLock);
1933 
1934  return hLock;
1935 }
1936 
1937 
1938 static VOID
1940 {
1941  HANDLE hEvent;
1942 
1943  TRACE("WaitForSCManager()\n");
1944 
1945  /* Try to open the existing event */
1947  if (hEvent == NULL)
1948  {
1950  return;
1951 
1952  /* Try to create a new event */
1954  if (hEvent == NULL)
1955  return;
1956  }
1957 
1958  /* Wait for 3 minutes */
1959  WaitForSingleObject(hEvent, 180000);
1961 
1962  TRACE("ScmWaitForSCManager() done\n");
1963 }
1964 
1965 
1966 /**********************************************************************
1967  * OpenSCManagerA
1968  *
1969  * @implemented
1970  */
1971 SC_HANDLE WINAPI
1972 OpenSCManagerA(LPCSTR lpMachineName,
1973  LPCSTR lpDatabaseName,
1974  DWORD dwDesiredAccess)
1975 {
1976  SC_HANDLE hScm = NULL;
1977  DWORD dwError;
1978 
1979  TRACE("OpenSCManagerA(%s %s %lx)\n",
1980  debugstr_a(lpMachineName), debugstr_a(lpDatabaseName), dwDesiredAccess);
1981 
1982  WaitForSCManager();
1983 
1984  RpcTryExcept
1985  {
1986  dwError = ROpenSCManagerA((LPSTR)lpMachineName,
1987  (LPSTR)lpDatabaseName,
1988  dwDesiredAccess,
1989  (SC_RPC_HANDLE *)&hScm);
1990  }
1992  {
1994  }
1995  RpcEndExcept;
1996 
1997  SetLastError(dwError);
1998  if (dwError != ERROR_SUCCESS)
1999  {
2000  TRACE("ROpenSCManagerA() failed (Error %lu)\n", dwError);
2001  return NULL;
2002  }
2003 
2004  TRACE("hScm = %p\n", hScm);
2005 
2006  return hScm;
2007 }
2008 
2009 
2010 /**********************************************************************
2011  * OpenSCManagerW
2012  *
2013  * @implemented
2014  */
2015 SC_HANDLE WINAPI
2016 OpenSCManagerW(LPCWSTR lpMachineName,
2017  LPCWSTR lpDatabaseName,
2018  DWORD dwDesiredAccess)
2019 {
2020  SC_HANDLE hScm = NULL;
2021  DWORD dwError;
2022 
2023  TRACE("OpenSCManagerW(%s %s %lx)\n",
2024  debugstr_w(lpMachineName), debugstr_w(lpDatabaseName), dwDesiredAccess);
2025 
2026  WaitForSCManager();
2027 
2028  RpcTryExcept
2029  {
2030  dwError = ROpenSCManagerW((LPWSTR)lpMachineName,
2031  (LPWSTR)lpDatabaseName,
2032  dwDesiredAccess,
2033  (SC_RPC_HANDLE *)&hScm);
2034  }
2036  {
2038  }
2039  RpcEndExcept;
2040 
2041  SetLastError(dwError);
2042  if (dwError != ERROR_SUCCESS)
2043  {
2044  TRACE("ROpenSCManagerW() failed (Error %lu)\n", dwError);
2045  return NULL;
2046  }
2047 
2048  TRACE("hScm = %p\n", hScm);
2049 
2050  return hScm;
2051 }
2052 
2053 
2054 /**********************************************************************
2055  * OpenServiceA
2056  *
2057  * @implemented
2058  */
2059 SC_HANDLE WINAPI
2061  LPCSTR lpServiceName,
2062  DWORD dwDesiredAccess)
2063 {
2064  SC_HANDLE hService = NULL;
2065  DWORD dwError;
2066 
2067  TRACE("OpenServiceA(%p %s %lx)\n",
2068  hSCManager, debugstr_a(lpServiceName), dwDesiredAccess);
2069 
2070  if (!hSCManager)
2071  {
2073  return NULL;
2074  }
2075 
2076  RpcTryExcept
2077  {
2079  (LPSTR)lpServiceName,
2080  dwDesiredAccess,
2081  (SC_RPC_HANDLE *)&hService);
2082  }
2084  {
2086  }
2087  RpcEndExcept;
2088 
2089  SetLastError(dwError);
2090  if (dwError != ERROR_SUCCESS)
2091  {
2092  TRACE("ROpenServiceA() failed (Error %lu)\n", dwError);
2093  return NULL;
2094  }
2095 
2096  TRACE("hService = %p\n", hService);
2097 
2098  return hService;
2099 }
2100 
2101 
2102 /**********************************************************************
2103  * OpenServiceW
2104  *
2105  * @implemented
2106  */
2107 SC_HANDLE WINAPI
2109  LPCWSTR lpServiceName,
2110  DWORD dwDesiredAccess)
2111 {
2112  SC_HANDLE hService = NULL;
2113  DWORD dwError;
2114 
2115  TRACE("OpenServiceW(%p %s %lx)\n",
2116  hSCManager, debugstr_w(lpServiceName), dwDesiredAccess);
2117 
2118  if (!hSCManager)
2119  {
2121  return NULL;
2122  }
2123 
2124  RpcTryExcept
2125  {
2127  (LPWSTR)lpServiceName,
2128  dwDesiredAccess,
2129  (SC_RPC_HANDLE *)&hService);
2130  }
2132  {
2134  }
2135  RpcEndExcept;
2136 
2137  SetLastError(dwError);
2138  if (dwError != ERROR_SUCCESS)
2139  {
2140  TRACE("ROpenServiceW() failed (Error %lu)\n", dwError);
2141  return NULL;
2142  }
2143 
2144  TRACE("hService = %p\n", hService);
2145 
2146  return hService;
2147 }
2148 
2149 
2150 /**********************************************************************
2151  * QueryServiceConfigA
2152  *
2153  * @implemented
2154  */
2155 BOOL WINAPI
2156 QueryServiceConfigA(SC_HANDLE hService,
2157  LPQUERY_SERVICE_CONFIGA lpServiceConfig,
2158  DWORD cbBufSize,
2160 {
2161  QUERY_SERVICE_CONFIGA ServiceConfig;
2162  LPQUERY_SERVICE_CONFIGA lpConfigPtr;
2163  DWORD dwBufferSize;
2164  DWORD dwError;
2165 
2166  TRACE("QueryServiceConfigA(%p %p %lu %p)\n",
2167  hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
2168 
2169  if (lpServiceConfig == NULL ||
2170  cbBufSize < sizeof(QUERY_SERVICE_CONFIGA))
2171  {
2172  lpConfigPtr = &ServiceConfig;
2173  dwBufferSize = sizeof(QUERY_SERVICE_CONFIGA);
2174  }
2175  else
2176  {
2177  lpConfigPtr = lpServiceConfig;
2178  dwBufferSize = cbBufSize;
2179  }
2180 
2181  RpcTryExcept
2182  {
2183  dwError = RQueryServiceConfigA((SC_RPC_HANDLE)hService,
2184  (LPBYTE)lpConfigPtr,
2185  dwBufferSize,
2186  pcbBytesNeeded);
2187  }
2189  {
2191  }
2192  RpcEndExcept;
2193 
2194  if (dwError != ERROR_SUCCESS)
2195  {
2196  TRACE("RQueryServiceConfigA() failed (Error %lu)\n", dwError);
2197  SetLastError(dwError);
2198  return FALSE;
2199  }
2200 
2201  /* Adjust the pointers */
2202  if (lpConfigPtr->lpBinaryPathName)
2203  lpConfigPtr->lpBinaryPathName =
2204  (LPSTR)((ULONG_PTR)lpConfigPtr +
2205  (ULONG_PTR)lpConfigPtr->lpBinaryPathName);
2206 
2207  if (lpConfigPtr->lpLoadOrderGroup)
2208  lpConfigPtr->lpLoadOrderGroup =
2209  (LPSTR)((ULONG_PTR)lpConfigPtr +
2210  (ULONG_PTR)lpConfigPtr->lpLoadOrderGroup);
2211 
2212  if (lpConfigPtr->lpDependencies)
2213  lpConfigPtr->lpDependencies =
2214  (LPSTR)((ULONG_PTR)lpConfigPtr +
2215  (ULONG_PTR)lpConfigPtr->lpDependencies);
2216 
2217  if (lpConfigPtr->lpServiceStartName)
2218  lpConfigPtr->lpServiceStartName =
2219  (LPSTR)((ULONG_PTR)lpConfigPtr +
2220  (ULONG_PTR)lpConfigPtr->lpServiceStartName);
2221 
2222  if (lpConfigPtr->lpDisplayName)
2223  lpConfigPtr->lpDisplayName =
2224  (LPSTR)((ULONG_PTR)lpConfigPtr +
2225  (ULONG_PTR)lpConfigPtr->lpDisplayName);
2226 
2227  TRACE("QueryServiceConfigA() done\n");
2228 
2229  return TRUE;
2230 }
2231 
2232 
2233 /**********************************************************************
2234  * QueryServiceConfigW
2235  *
2236  * @implemented
2237  */
2238 BOOL WINAPI
2239 QueryServiceConfigW(SC_HANDLE hService,
2240  LPQUERY_SERVICE_CONFIGW lpServiceConfig,
2241  DWORD cbBufSize,
2243 {
2244  QUERY_SERVICE_CONFIGW ServiceConfig;
2245  LPQUERY_SERVICE_CONFIGW lpConfigPtr;
2246  DWORD dwBufferSize;
2247  DWORD dwError;
2248 
2249  TRACE("QueryServiceConfigW(%p %p %lu %p)\n",
2250  hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
2251 
2252  if (lpServiceConfig == NULL ||
2253  cbBufSize < sizeof(QUERY_SERVICE_CONFIGW))
2254  {
2255  lpConfigPtr = &ServiceConfig;
2256  dwBufferSize = sizeof(QUERY_SERVICE_CONFIGW);
2257  }
2258  else
2259  {
2260  lpConfigPtr = lpServiceConfig;
2261  dwBufferSize = cbBufSize;
2262  }
2263 
2264  RpcTryExcept
2265  {
2266  dwError = RQueryServiceConfigW((SC_RPC_HANDLE)hService,
2267  (LPBYTE)lpConfigPtr,
2268  dwBufferSize,
2269  pcbBytesNeeded);
2270  }
2272  {
2274  }
2275  RpcEndExcept;
2276 
2277  if (dwError != ERROR_SUCCESS)
2278  {
2279  TRACE("RQueryServiceConfigW() failed (Error %lu)\n", dwError);
2280  SetLastError(dwError);
2281  return FALSE;
2282  }
2283 
2284  /* Adjust the pointers */
2285  if (lpConfigPtr->lpBinaryPathName)
2286  lpConfigPtr->lpBinaryPathName =
2287  (LPWSTR)((ULONG_PTR)lpConfigPtr +
2288  (ULONG_PTR)lpConfigPtr->lpBinaryPathName);
2289 
2290  if (lpConfigPtr->lpLoadOrderGroup)
2291  lpConfigPtr->lpLoadOrderGroup =
2292  (LPWSTR)((ULONG_PTR)lpConfigPtr +
2293  (ULONG_PTR)lpConfigPtr->lpLoadOrderGroup);
2294 
2295  if (lpConfigPtr->lpDependencies)
2296  lpConfigPtr->lpDependencies =
2297  (LPWSTR)((ULONG_PTR)lpConfigPtr +
2298  (ULONG_PTR)lpConfigPtr->lpDependencies);
2299 
2300  if (lpConfigPtr->lpServiceStartName)
2301  lpConfigPtr->lpServiceStartName =
2302  (LPWSTR)((ULONG_PTR)lpConfigPtr +
2303  (ULONG_PTR)lpConfigPtr->lpServiceStartName);
2304 
2305  if (lpConfigPtr->lpDisplayName)
2306  lpConfigPtr->lpDisplayName =
2307  (LPWSTR)((ULONG_PTR)lpConfigPtr +
2308  (ULONG_PTR)lpConfigPtr->lpDisplayName);
2309 
2310  TRACE("QueryServiceConfigW() done\n");
2311 
2312  return TRUE;
2313 }
2314 
2315 
2316 /**********************************************************************
2317  * QueryServiceConfig2A
2318  *
2319  * @implemented
2320  */
2321 BOOL WINAPI
2322 QueryServiceConfig2A(SC_HANDLE hService,
2324  LPBYTE lpBuffer,
2325  DWORD cbBufSize,
2327 {
2328  SERVICE_DESCRIPTIONA ServiceDescription;
2329  SERVICE_FAILURE_ACTIONSA ServiceFailureActions;
2330  LPBYTE lpTempBuffer;
2331  BOOL bUseTempBuffer = FALSE;
2332  DWORD dwBufferSize;
2333  DWORD dwError;
2334 
2335  TRACE("QueryServiceConfig2A(%p %lu %p %lu %p)\n",
2337 
2338  lpTempBuffer = lpBuffer;
2339  dwBufferSize = cbBufSize;
2340 
2341  switch (dwInfoLevel)
2342  {
2344  if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_DESCRIPTIONA)))
2345  {
2346  lpTempBuffer = (LPBYTE)&ServiceDescription;
2347  dwBufferSize = sizeof(SERVICE_DESCRIPTIONA);
2348  bUseTempBuffer = TRUE;
2349  }
2350  break;
2351 
2353  if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_FAILURE_ACTIONSA)))
2354  {
2355  lpTempBuffer = (LPBYTE)&ServiceFailureActions;
2356  dwBufferSize = sizeof(SERVICE_FAILURE_ACTIONSA);
2357  bUseTempBuffer = TRUE;
2358  }
2359  break;
2360 
2361  default:
2362  WARN("Unknown info level 0x%lx\n", dwInfoLevel);
2364  return FALSE;
2365  }
2366 
2367  RpcTryExcept
2368  {
2369  dwError = RQueryServiceConfig2A((SC_RPC_HANDLE)hService,
2370  dwInfoLevel,
2371  lpTempBuffer,
2372  dwBufferSize,
2373  pcbBytesNeeded);
2374  }
2376  {
2378  }
2379  RpcEndExcept;
2380 
2381  if (dwError != ERROR_SUCCESS)
2382  {
2383  TRACE("RQueryServiceConfig2A() failed (Error %lu)\n", dwError);
2384  SetLastError(dwError);
2385  return FALSE;
2386  }
2387 
2388  if (bUseTempBuffer != FALSE)
2389  {
2390  TRACE("RQueryServiceConfig2A() returns ERROR_INSUFFICIENT_BUFFER\n");
2391  *pcbBytesNeeded = dwBufferSize;
2393  return FALSE;
2394  }
2395 
2396  switch (dwInfoLevel)
2397  {
2399  {
2400  LPSERVICE_DESCRIPTIONA lpPtr = (LPSERVICE_DESCRIPTIONA)lpTempBuffer;
2401 
2402  if (lpPtr->lpDescription != NULL)
2403  lpPtr->lpDescription =
2404  (LPSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpDescription);
2405  }
2406  break;
2407 
2409  {
2411 
2412  if (lpPtr->lpRebootMsg != NULL)
2413  lpPtr->lpRebootMsg =
2414  (LPSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpRebootMsg);
2415 
2416  if (lpPtr->lpCommand != NULL)
2417  lpPtr->lpCommand =
2418  (LPSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpCommand);
2419 
2420  if (lpPtr->lpsaActions != NULL)
2421  lpPtr->lpsaActions =
2422  (LPSC_ACTION)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpsaActions);
2423  }
2424  break;
2425  }
2426 
2427  TRACE("QueryServiceConfig2A() done\n");
2428 
2429  return TRUE;
2430 }
2431 
2432 
2433 /**********************************************************************
2434  * QueryServiceConfig2W
2435  *
2436  * @implemented
2437  */
2438 BOOL WINAPI
2439 QueryServiceConfig2W(SC_HANDLE hService,
2441  LPBYTE lpBuffer,
2442  DWORD cbBufSize,
2444 {
2445  SERVICE_DESCRIPTIONW ServiceDescription;
2446  SERVICE_FAILURE_ACTIONSW ServiceFailureActions;
2447  LPBYTE lpTempBuffer;
2448  BOOL bUseTempBuffer = FALSE;
2449  DWORD dwBufferSize;
2450  DWORD dwError;
2451 
2452  TRACE("QueryServiceConfig2W(%p %lu %p %lu %p)\n",
2454 
2455  lpTempBuffer = lpBuffer;
2456  dwBufferSize = cbBufSize;
2457 
2458  switch (dwInfoLevel)
2459  {
2461  if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_DESCRIPTIONW)))
2462  {
2463  lpTempBuffer = (LPBYTE)&ServiceDescription;
2464  dwBufferSize = sizeof(SERVICE_DESCRIPTIONW);
2465  bUseTempBuffer = TRUE;
2466  }
2467  break;
2468 
2470  if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_FAILURE_ACTIONSW)))
2471  {
2472  lpTempBuffer = (LPBYTE)&ServiceFailureActions;
2473  dwBufferSize = sizeof(SERVICE_FAILURE_ACTIONSW);
2474  bUseTempBuffer = TRUE;
2475  }
2476  break;
2477 
2478  default:
2479  WARN("Unknown info level 0x%lx\n", dwInfoLevel);
2481  return FALSE;
2482  }
2483 
2484  RpcTryExcept
2485  {
2486  dwError = RQueryServiceConfig2W((SC_RPC_HANDLE)hService,
2487  dwInfoLevel,
2488  lpTempBuffer,
2489  dwBufferSize,
2490  pcbBytesNeeded);
2491  }
2493  {
2495  }
2496  RpcEndExcept;
2497 
2498  if (dwError != ERROR_SUCCESS)
2499  {
2500  TRACE("RQueryServiceConfig2W() failed (Error %lu)\n", dwError);
2501  SetLastError(dwError);
2502  return FALSE;
2503  }
2504 
2505  if (bUseTempBuffer != FALSE)
2506  {
2507  TRACE("RQueryServiceConfig2W() returns ERROR_INSUFFICIENT_BUFFER\n");
2508  *pcbBytesNeeded = dwBufferSize;
2510  return FALSE;
2511  }
2512 
2513  switch (dwInfoLevel)
2514  {
2516  {
2517  LPSERVICE_DESCRIPTIONW lpPtr = (LPSERVICE_DESCRIPTIONW)lpTempBuffer;
2518 
2519  if (lpPtr->lpDescription != NULL)
2520  lpPtr->lpDescription =
2521  (LPWSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpDescription);
2522  }
2523  break;
2524 
2526  {
2528 
2529  if (lpPtr->lpRebootMsg != NULL)
2530  lpPtr->lpRebootMsg =
2531  (LPWSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpRebootMsg);
2532 
2533  if (lpPtr->lpCommand != NULL)
2534  lpPtr->lpCommand =
2535  (LPWSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpCommand);
2536 
2537  if (lpPtr->lpsaActions != NULL)
2538  lpPtr->lpsaActions =
2539  (LPSC_ACTION)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpsaActions);
2540  }
2541  break;
2542  }
2543 
2544  TRACE("QueryServiceConfig2W() done\n");
2545 
2546  return TRUE;
2547 }
2548 
2549 
2550 /**********************************************************************
2551  * QueryServiceLockStatusA
2552  *
2553  * @implemented
2554  */
2555 BOOL WINAPI
2557  LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus,
2558  DWORD cbBufSize,
2560 {
2561  QUERY_SERVICE_LOCK_STATUSA LockStatus;
2562  LPQUERY_SERVICE_LOCK_STATUSA lpStatusPtr;
2563  DWORD dwBufferSize;
2564  DWORD dwError;
2565 
2566  TRACE("QueryServiceLockStatusA(%p %p %lu %p)\n",
2567  hSCManager, lpLockStatus, cbBufSize, pcbBytesNeeded);
2568 
2569  if (lpLockStatus == NULL || cbBufSize < sizeof(QUERY_SERVICE_LOCK_STATUSA))
2570  {
2571  lpStatusPtr = &LockStatus;
2572  dwBufferSize = sizeof(QUERY_SERVICE_LOCK_STATUSA);
2573  }
2574  else
2575  {
2576  lpStatusPtr = lpLockStatus;
2577  dwBufferSize = cbBufSize;
2578  }
2579 
2580  RpcTryExcept
2581  {
2583  (LPBYTE)lpStatusPtr,
2584  dwBufferSize,
2585  pcbBytesNeeded);
2586  }
2588  {
2590  }
2591  RpcEndExcept;
2592 
2593  if (dwError != ERROR_SUCCESS)
2594  {
2595  TRACE("RQueryServiceLockStatusA() failed (Error %lu)\n", dwError);
2596  SetLastError(dwError);
2597  return FALSE;
2598  }
2599 
2600  if (lpStatusPtr->lpLockOwner != NULL)
2601  {
2602  lpStatusPtr->lpLockOwner =
2603  (LPSTR)((ULONG_PTR)lpStatusPtr + (ULONG_PTR)lpStatusPtr->lpLockOwner);
2604  }
2605 
2606  TRACE("QueryServiceLockStatusA() done\n");
2607 
2608  return TRUE;
2609 }
2610 
2611 
2612 /**********************************************************************
2613  * QueryServiceLockStatusW
2614  *
2615  * @implemented
2616  */
2617 BOOL WINAPI
2619  LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus,
2620  DWORD cbBufSize,
2622 {
2623  QUERY_SERVICE_LOCK_STATUSW LockStatus;
2624  LPQUERY_SERVICE_LOCK_STATUSW lpStatusPtr;
2625  DWORD dwBufferSize;
2626  DWORD dwError;
2627 
2628  TRACE("QueryServiceLockStatusW(%p %p %lu %p)\n",
2629  hSCManager, lpLockStatus, cbBufSize, pcbBytesNeeded);
2630 
2631  if (lpLockStatus == NULL || cbBufSize < sizeof(QUERY_SERVICE_LOCK_STATUSW))
2632  {
2633  lpStatusPtr = &LockStatus;
2634  dwBufferSize = sizeof(QUERY_SERVICE_LOCK_STATUSW);
2635  }
2636  else
2637  {
2638  lpStatusPtr = lpLockStatus;
2639  dwBufferSize = cbBufSize;
2640  }
2641 
2642  RpcTryExcept
2643  {
2645  (LPBYTE)lpStatusPtr,
2646  dwBufferSize,
2647  pcbBytesNeeded);
2648  }
2650  {
2652  }
2653  RpcEndExcept;
2654 
2655  if (dwError != ERROR_SUCCESS)
2656  {
2657  TRACE("RQueryServiceLockStatusW() failed (Error %lu)\n", dwError);
2658  SetLastError(dwError);
2659  return FALSE;
2660  }
2661 
2662  if (lpStatusPtr->lpLockOwner != NULL)
2663  {
2664  lpStatusPtr->lpLockOwner =
2665  (LPWSTR)((ULONG_PTR)lpStatusPtr + (ULONG_PTR)lpStatusPtr->lpLockOwner);
2666  }
2667 
2668  TRACE("QueryServiceLockStatusW() done\n");
2669 
2670  return TRUE;
2671 }
2672 
2673 
2674 /**********************************************************************
2675  * QueryServiceObjectSecurity
2676  *
2677  * @implemented
2678  */
2679 BOOL WINAPI
2680 QueryServiceObjectSecurity(SC_HANDLE hService,
2681  SECURITY_INFORMATION dwSecurityInformation,
2682  PSECURITY_DESCRIPTOR lpSecurityDescriptor,
2683  DWORD cbBufSize,
2685 {
2686  DWORD dwError;
2687 
2688  TRACE("QueryServiceObjectSecurity(%p %lu %p)\n",
2689  hService, dwSecurityInformation, lpSecurityDescriptor);
2690 
2691  RpcTryExcept
2692  {
2693  dwError = RQueryServiceObjectSecurity((SC_RPC_HANDLE)hService,
2694  dwSecurityInformation,
2695  (LPBYTE)lpSecurityDescriptor,
2696  cbBufSize,
2697  pcbBytesNeeded);
2698  }
2700  {
2702  }
2703  RpcEndExcept;
2704 
2705  if (dwError != ERROR_SUCCESS)
2706  {
2707  TRACE("QueryServiceObjectSecurity() failed (Error %lu)\n", dwError);
2708  SetLastError(dwError);
2709  return FALSE;
2710  }
2711 
2712  return TRUE;
2713 }
2714 
2715 
2716 /**********************************************************************
2717  * SetServiceObjectSecurity
2718  *
2719  * @implemented
2720  */
2721 BOOL WINAPI
2722 SetServiceObjectSecurity(SC_HANDLE hService,
2723  SECURITY_INFORMATION dwSecurityInformation,
2724  PSECURITY_DESCRIPTOR lpSecurityDescriptor)
2725 {
2726  PSECURITY_DESCRIPTOR SelfRelativeSD = NULL;
2727  ULONG Length;
2728  NTSTATUS Status;
2729  DWORD dwError;
2730 
2731  TRACE("SetServiceObjectSecurity(%p %lu %p)\n",
2732  hService, dwSecurityInformation, lpSecurityDescriptor);
2733 
2734  Length = 0;
2735  Status = RtlMakeSelfRelativeSD(lpSecurityDescriptor,
2736  SelfRelativeSD,
2737  &Length);
2739  {
2741  return FALSE;
2742  }
2743 
2744  SelfRelativeSD = HeapAlloc(GetProcessHeap(), 0, Length);
2745  if (SelfRelativeSD == NULL)
2746  {
2748  return FALSE;
2749  }
2750 
2751  Status = RtlMakeSelfRelativeSD(lpSecurityDescriptor,
2752  SelfRelativeSD,
2753  &Length);
2754  if (!NT_SUCCESS(Status))
2755  {
2756  HeapFree(GetProcessHeap(), 0, SelfRelativeSD);
2758  return FALSE;
2759  }
2760 
2761  RpcTryExcept
2762  {
2763  dwError = RSetServiceObjectSecurity((SC_RPC_HANDLE)hService,
2764  dwSecurityInformation,
2765  (LPBYTE)SelfRelativeSD,
2766  Length);
2767  }
2769  {
2771  }
2772  RpcEndExcept;
2773 
2774  HeapFree(GetProcessHeap(), 0, SelfRelativeSD);
2775 
2776  if (dwError != ERROR_SUCCESS)
2777  {
2778  TRACE("RServiceObjectSecurity() failed (Error %lu)\n", dwError);
2779  SetLastError(dwError);
2780  return FALSE;
2781  }
2782 
2783  return TRUE;
2784 }
2785 
2786 
2787 /**********************************************************************
2788  * QueryServiceStatus
2789  *
2790  * @implemented
2791  */
2792 BOOL WINAPI
2793 QueryServiceStatus(SC_HANDLE hService,
2794  LPSERVICE_STATUS lpServiceStatus)
2795 {
2796  DWORD dwError;
2797 
2798  TRACE("QueryServiceStatus(%p %p)\n",
2799  hService, lpServiceStatus);
2800 
2801  if (!hService)
2802  {
2804  return FALSE;
2805  }
2806 
2807  RpcTryExcept
2808  {
2809  dwError = RQueryServiceStatus((SC_RPC_HANDLE)hService,
2810  lpServiceStatus);
2811  }
2813  {
2815  }
2816  RpcEndExcept;
2817 
2818  if (dwError != ERROR_SUCCESS)
2819  {
2820  TRACE("RQueryServiceStatus() failed (Error %lu)\n", dwError);
2821  SetLastError(dwError);
2822  return FALSE;
2823  }
2824 
2825  return TRUE;
2826 }
2827 
2828 
2829 /**********************************************************************
2830  * QueryServiceStatusEx
2831  *
2832  * @implemented
2833  */
2834 BOOL WINAPI
2835 QueryServiceStatusEx(SC_HANDLE hService,
2836  SC_STATUS_TYPE InfoLevel,
2837  LPBYTE lpBuffer,
2838  DWORD cbBufSize,
2840 {
2841  DWORD dwError;
2842 
2843  TRACE("QueryServiceStatusEx(%p %lu %p %lu %p)\n",
2844  hService, InfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
2845 
2846  if (InfoLevel != SC_STATUS_PROCESS_INFO)
2847  {
2849  return FALSE;
2850  }
2851 
2852  if (cbBufSize < sizeof(SERVICE_STATUS_PROCESS))
2853  {
2856  return FALSE;
2857  }
2858 
2859  RpcTryExcept
2860  {
2861  dwError = RQueryServiceStatusEx((SC_RPC_HANDLE)hService,
2862  InfoLevel,
2863  lpBuffer,
2864  cbBufSize,
2865  pcbBytesNeeded);
2866  }
2868  {
2870  }
2871  RpcEndExcept;
2872 
2873  if (dwError != ERROR_SUCCESS)
2874  {
2875  TRACE("RQueryServiceStatusEx() failed (Error %lu)\n", dwError);
2876  SetLastError(dwError);
2877  return FALSE;
2878  }
2879 
2880  return TRUE;
2881 }
2882 
2883 
2884 /**********************************************************************
2885  * StartServiceA
2886  *
2887  * @implemented
2888  */
2889 BOOL WINAPI
2890 StartServiceA(SC_HANDLE hService,
2891  DWORD dwNumServiceArgs,
2892  LPCSTR *lpServiceArgVectors)
2893 {
2894  DWORD dwError;
2895 
2896  TRACE("StartServiceA(%p %lu %p)\n",
2897  hService, dwNumServiceArgs, lpServiceArgVectors);
2898 
2899  RpcTryExcept
2900  {
2901  dwError = RStartServiceA((SC_RPC_HANDLE)hService,
2902  dwNumServiceArgs,
2903  (LPSTRING_PTRSA)lpServiceArgVectors);
2904  }
2906  {
2908  }
2909  RpcEndExcept;
2910 
2911  if (dwError != ERROR_SUCCESS)
2912  {
2913  ERR("RStartServiceA() failed (Error %lu)\n", dwError);
2914  SetLastError(dwError);
2915  return FALSE;
2916  }
2917 
2918  return TRUE;
2919 }
2920 
2921 
2922 /**********************************************************************
2923  * StartServiceW
2924  *
2925  * @implemented
2926  */
2927 BOOL WINAPI
2928 StartServiceW(SC_HANDLE hService,
2929  DWORD dwNumServiceArgs,
2930  LPCWSTR *lpServiceArgVectors)
2931 {
2932  DWORD dwError;
2933 
2934  TRACE("StartServiceW(%p %lu %p)\n",
2935  hService, dwNumServiceArgs, lpServiceArgVectors);
2936 
2937  RpcTryExcept
2938  {
2939  dwError = RStartServiceW((SC_RPC_HANDLE)hService,
2940  dwNumServiceArgs,
2941  (LPSTRING_PTRSW)lpServiceArgVectors);
2942  }
2944  {
2946  }
2947  RpcEndExcept;
2948 
2949  if (dwError != ERROR_SUCCESS)
2950  {
2951  ERR("RStartServiceW() failed (Error %lu)\n", dwError);
2952  SetLastError(dwError);
2953  return FALSE;
2954  }
2955 
2956  return TRUE;
2957 }
2958 
2959 
2960 /**********************************************************************
2961  * UnlockServiceDatabase
2962  *
2963  * @implemented
2964  */
2965 BOOL WINAPI
2967 {
2968  DWORD dwError;
2969 
2970  TRACE("UnlockServiceDatabase(%x)\n",
2971  ScLock);
2972 
2973  RpcTryExcept
2974  {
2975  dwError = RUnlockServiceDatabase((LPSC_RPC_LOCK)&ScLock);
2976  }
2978  {
2980  }
2981  RpcEndExcept;
2982 
2983  if (dwError == ERROR_INVALID_HANDLE)
2984  dwError = ERROR_INVALID_SERVICE_LOCK;
2985 
2986  if (dwError != ERROR_SUCCESS)
2987  {
2988  TRACE("RUnlockServiceDatabase() failed (Error %lu)\n", dwError);
2989  SetLastError(dwError);
2990  return FALSE;
2991  }
2992 
2993  return TRUE;
2994 }
2995 
2996 
2997 /**********************************************************************
2998  * NotifyBootConfigStatus
2999  *
3000  * @implemented
3001  */
3002 BOOL WINAPI
3004 {
3005  DWORD dwError;
3006 
3007  TRACE("NotifyBootConfigStatus(%u)\n",
3008  BootAcceptable);
3009 
3010  RpcTryExcept
3011  {
3012  dwError = RNotifyBootConfigStatus(NULL,
3013  BootAcceptable);
3014  }
3016  {
3018  }
3019  RpcEndExcept;
3020 
3021  if (dwError != ERROR_SUCCESS)
3022  {
3023  TRACE("NotifyBootConfigStatus() failed (Error %lu)\n", dwError);
3024  SetLastError(dwError);
3025  return FALSE;
3026  }
3027 
3028  return TRUE;
3029 }
3030 
3031 DWORD
3034  PTAG_INFO_NAME_FROM_TAG InOutParams)
3035 {
3036  SC_HANDLE hScm;
3037  DWORD dwError;
3040  LPWSTR lpszName;
3041 
3042  /* We only support one class */
3044  {
3045  return ERROR_RETRY;
3046  }
3047 
3048  /* Validate input structure */
3049  if (InOutParams->InParams.dwPid == 0 || InOutParams->InParams.dwTag == 0)
3050  {
3051  return ERROR_INVALID_PARAMETER;
3052  }
3053 
3054  /* Validate output structure */
3055  if (InOutParams->OutParams.pszName != NULL)
3056  {
3057  return ERROR_INVALID_PARAMETER;
3058  }
3059 
3060  /* Open service manager */
3062  if (hScm == NULL)
3063  {
3064  return GetLastError();
3065  }
3066 
3067  /* Setup call parameters */
3068  InParams = &InOutParams->InParams;
3069  OutParams = NULL;
3070 
3071  /* Call SCM to query tag information */
3072  RpcTryExcept
3073  {
3074  dwError = RI_ScQueryServiceTagInfo(hScm, TagInfoLevelNameFromTag, &InParams, &OutParams);
3075  }
3077  {
3079  }
3080  RpcEndExcept;
3081 
3082  /* Quit if not a success */
3083  if (dwError != ERROR_SUCCESS)
3084  {
3085  goto Cleanup;
3086  }
3087 
3088  /* OutParams must be set now and we must have a name */
3089  if (OutParams == NULL ||
3090  OutParams->pszName == NULL)
3091  {
3092  dwError = ERROR_INVALID_DATA;
3093  goto Cleanup;
3094  }
3095 
3096  /* Copy back what SCM returned */
3097  lpszName = LocalAlloc(LPTR,
3098  sizeof(WCHAR) * wcslen(OutParams->pszName) + sizeof(UNICODE_NULL));
3099  if (lpszName == NULL)
3100  {
3101  dwError = GetLastError();
3102  goto Cleanup;
3103  }
3104 
3105  wcscpy(lpszName, OutParams->pszName);
3106  InOutParams->OutParams.pszName = lpszName;
3107  InOutParams->OutParams.TagType = OutParams->TagType;
3108 
3109 Cleanup:
3110  CloseServiceHandle(hScm);
3111 
3112  /* Free memory allocated by SCM */
3113  if (OutParams != NULL)
3114  {
3115  if (OutParams->pszName != NULL)
3116  {
3117  midl_user_free(OutParams->pszName);
3118  }
3119 
3120  midl_user_free(OutParams);
3121  }
3122 
3123  return dwError;
3124 }
3125 
3126 /**********************************************************************
3127  * I_QueryTagInformation
3128  *
3129  * @implemented
3130  */
3131 DWORD WINAPI
3134  PTAG_INFO_NAME_FROM_TAG InOutParams)
3135 {
3136  /*
3137  * We only support one information class and it
3138  * needs parameters
3139  */
3141  InOutParams == NULL)
3142  {
3143  return ERROR_INVALID_PARAMETER;
3144  }
3145 
3146  /* Validate input structure */
3147  if (InOutParams->InParams.dwPid == 0 || InOutParams->InParams.dwTag == 0)
3148  {
3149  return ERROR_INVALID_PARAMETER;
3150  }
3151 
3152  /* Validate output structure */
3153  if (InOutParams->OutParams.pszName != NULL)
3154  {
3155  return ERROR_INVALID_PARAMETER;
3156  }
3157 
3158  /* Call internal function for the RPC call */
3160 }
3161 
3162 /* EOF */
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
DWORD WINAPI REnumServicesStatusExA(SC_RPC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeIndex, LPCSTR pszGroupName)
Definition: rpcserver.c:6096
RPC_STATUS WINAPI RpcBindingFromStringBindingW(RPC_WSTR StringBinding, RPC_BINDING_HANDLE *Binding)
Definition: rpc_binding.c:876
DWORD WINAPI RChangeServiceConfigA(SC_RPC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPSTR lpBinaryPathName, LPSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPBYTE lpDependencies, DWORD dwDependSize, LPSTR lpServiceStartName, LPBYTE lpPassword, DWORD dwPwSize, LPSTR lpDisplayName)
Definition: rpcserver.c:3461
#define RPC_X_SS_IN_NULL_CONTEXT
Definition: winerror.h:1083
DWORD I_ScQueryServiceTagInfo(PVOID Unused, TAG_INFO_LEVEL dwInfoLevel, PTAG_INFO_NAME_FROM_TAG InOutParams)
Definition: scm.c:3032
static VOID WaitForSCManager(VOID)
Definition: scm.c:1939
DWORD WINAPI RQueryServiceConfigW(SC_RPC_HANDLE hService, LPBYTE lpBuf, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
Definition: rpcserver.c:3003
_Must_inspect_result_ typedef _In_ PVOID Unused
Definition: iotypes.h:1166
DWORD WINAPI REnumServicesStatusA(SC_RPC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD dwBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeHandle)
Definition: rpcserver.c:3899
const uint16_t * PCWSTR
Definition: typedefs.h:57
#define IN
Definition: typedefs.h:39
#define SC_MANAGER_ENUMERATE_SERVICE
Definition: winsvc.h:16
#define midl_user_free
Definition: rpc.h:45
#define RpcEndExcept
Definition: rpc.h:128
RPC_STATUS WINAPI RpcBindingFree(RPC_BINDING_HANDLE *Binding)
Definition: rpc_binding.c:783
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
Definition: winsvc.h:424
struct _QUERY_SERVICE_CONFIGW QUERY_SERVICE_CONFIGW
#define CloseHandle
Definition: compat.h:598
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
struct _SERVICE_DESCRIPTIONA * LPSERVICE_DESCRIPTIONA
DWORD WINAPI RGetServiceDisplayNameW(SC_RPC_HANDLE hSCManager, LPCWSTR lpServiceName, LPWSTR lpDisplayName, DWORD *lpcchBuffer)
Definition: rpcserver.c:3317
#define ERROR_SUCCESS
Definition: deptool.c:10
#define RPC_X_NULL_REF_POINTER
Definition: winerror.h:1087
TAG_INFO_NAME_FROM_TAG_OUT_PARAMS OutParams
Definition: svcctl.idl:320
BOOL WINAPI QueryServiceConfigA(SC_HANDLE hService, LPQUERY_SERVICE_CONFIGA lpServiceConfig, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2156
TAG_INFO_NAME_FROM_TAG_IN_PARAMS InParams
Definition: svcctl.idl:319
DWORD WINAPI RCreateServiceW(SC_RPC_HANDLE hSCManager, LPCWSTR lpServiceName, LPCWSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName, LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPBYTE lpDependencies, DWORD dwDependSize, LPCWSTR lpServiceStartName, LPBYTE lpPassword, DWORD dwPwSize, LPSC_RPC_HANDLE lpServiceHandle)
Definition: rpcserver.c:2272
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
LPSTR lpServiceStartName
Definition: winsvc.h:152
handle_t hBinding
Definition: ctx_c.c:54
RPC_STATUS WINAPI RpcStringFreeW(RPC_WSTR *String)
Definition: rpcrt4_main.c:174
#define _Out_
Definition: ms_sal.h:345
DWORD WINAPI REnumServicesStatusExW(SC_RPC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeIndex, LPCWSTR pszGroupName)
Definition: rpcserver.c:6235
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
DWORD WINAPI REnumDependentServicesW(SC_RPC_HANDLE hService, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned)
Definition: rpcserver.c:2707
SC_HANDLE WINAPI CreateServiceW(SC_HANDLE hSCManager, LPCWSTR lpServiceName, LPCWSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName, LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCWSTR lpDependencies, LPCWSTR lpServiceStartName, LPCWSTR lpPassword)
Definition: scm.c:812
DWORD WINAPI RDeleteService(SC_RPC_HANDLE hService)
Definition: rpcserver.c:1304
#define TRUE
Definition: types.h:120
struct _SERVICE_STATUS_PROCESS SERVICE_STATUS_PROCESS
SC_ACTION * lpsaActions
Definition: winsvc.h:220
#define SecureZeroMemory
Definition: winbase.h:1665
BOOL WINAPI QueryServiceConfigW(SC_HANDLE hService, LPQUERY_SERVICE_CONFIGW lpServiceConfig, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2239
#define CP_ACP
Definition: compat.h:109
RPC_STATUS WINAPI RpcStringBindingComposeA(RPC_CSTR ObjUuid, RPC_CSTR Protseq, RPC_CSTR NetworkAddr, RPC_CSTR Endpoint, RPC_CSTR Options, RPC_CSTR *StringBinding)
Definition: rpc_binding.c:457
LPWSTR lpLoadOrderGroup
Definition: winsvc.h:160
BOOL WINAPI NotifyBootConfigStatus(BOOL BootAcceptable)
Definition: scm.c:3003
struct _QUERY_SERVICE_CONFIGA QUERY_SERVICE_CONFIGA
enum _SC_STATUS_TYPE SC_STATUS_TYPE
DWORD MaximumLength
Definition: config.c:21
char CHAR
Definition: xmlstorage.h:175
struct _SERVICE_FAILURE_ACTIONSA SERVICE_FAILURE_ACTIONSA
#define WARN(fmt,...)
Definition: debug.h:112
struct _SERVICE_DESCRIPTIONW SERVICE_DESCRIPTIONW
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
LONG NTSTATUS
Definition: precomp.h:26
#define RPC_X_BYTE_COUNT_TOO_SMALL
Definition: winerror.h:1089
static DWORD ScmEncryptPassword(_In_ PVOID ContextHandle, _In_ PCWSTR pClearTextPassword, _Out_ PBYTE *pEncryptedPassword, _Out_ PDWORD pEncryptedPasswordSize)
Definition: scm.c:173
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1040
BOOL WINAPI EnumServicesStatusA(SC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPENUM_SERVICE_STATUSA lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle)
Definition: scm.c:1222
BOOL WINAPI UnlockServiceDatabase(SC_LOCK ScLock)
Definition: scm.c:2966
#define SERVICE_CONFIG_DESCRIPTION
Definition: winsvc.h:65
BOOL WINAPI EnumServiceGroupW(SC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPENUM_SERVICE_STATUSW lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle, LPCWSTR lpGroup)
Definition: scm.c:1111
BOOL WINAPI QueryServiceStatusEx(SC_HANDLE hService, SC_STATUS_TYPE InfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2835
unsigned short * RPC_WSTR
Definition: rpcdce.h:46
BOOL WINAPI DeleteService(SC_HANDLE hService)
Definition: scm.c:921
DWORD WINAPI RQueryServiceObjectSecurity(SC_RPC_HANDLE hService, SECURITY_INFORMATION dwSecurityInformation, LPBYTE lpSecurityDescriptor, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded)
Definition: rpcserver.c:1390
char * LPSTR
Definition: xmlstorage.h:182
RPC_STATUS WINAPI RpcStringFreeA(RPC_CSTR *String)
Definition: rpcrt4_main.c:158
SC_HANDLE WINAPI CreateServiceA(SC_HANDLE hSCManager, LPCSTR lpServiceName, LPCSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpBinaryPathName, LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCSTR lpDependencies, LPCSTR lpServiceStartName, LPCSTR lpPassword)
Definition: scm.c:680
DWORD WINAPI ROpenSCManagerW(LPWSTR lpMachineName, LPWSTR lpDatabaseName, DWORD dwDesiredAccess, LPSC_RPC_HANDLE lpScHandle)
Definition: rpcserver.c:2868
#define DWORD
Definition: nt_native.h:44
BOOL WINAPI GetServiceDisplayNameA(SC_HANDLE hSCManager, LPCSTR lpServiceName, LPSTR lpDisplayName, LPDWORD lpcchBuffer)
Definition: scm.c:1626
DWORD WINAPI I_ScGetCurrentGroupStateW(SC_HANDLE hSCManager, LPWSTR pszGroupName, LPDWORD pdwGroupState)
Definition: scm.c:1869
RPC_STATUS WINAPI RpcStringBindingComposeW(RPC_WSTR ObjUuid, RPC_WSTR Protseq, RPC_WSTR NetworkAddr, RPC_WSTR Endpoint, RPC_WSTR Options, RPC_WSTR *StringBinding)
Definition: rpc_binding.c:510
DWORD WINAPI RStartServiceA(SC_RPC_HANDLE hService, DWORD argc, LPSTRING_PTRSA argv)
Definition: rpcserver.c:4358
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651
BOOL WINAPI ChangeServiceConfig2A(SC_HANDLE hService, DWORD dwInfoLevel, LPVOID lpInfo)
Definition: scm.c:247
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
HANDLE WINAPI DECLSPEC_HOTPATCH OpenEventW(IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN LPCWSTR lpName)
Definition: synch.c:682
static HANDLE hEvent
Definition: comm.c:54
uint32_t ULONG_PTR
Definition: typedefs.h:65
BOOL WINAPI GetServiceKeyNameW(SC_HANDLE hSCManager, LPCWSTR lpDisplayName, LPWSTR lpServiceName, LPDWORD lpcchBuffer)
Definition: scm.c:1806
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:683
void __RPC_USER SVCCTL_HANDLEW_unbind(SVCCTL_HANDLEW szMachineName, handle_t hBinding)
Definition: scm.c:129
DWORD Length
Definition: config.c:20
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
long RPC_STATUS
Definition: rpc.h:52
BOOL WINAPI EnumServicesStatusW(SC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPENUM_SERVICE_STATUSW lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle)
Definition: scm.c:1316
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
handle_t __RPC_USER SVCCTL_HANDLEA_bind(SVCCTL_HANDLEA szMachineName)
Definition: scm.c:32
unsigned char * LPBYTE
Definition: typedefs.h:53
SC_HANDLE WINAPI OpenSCManagerA(LPCSTR lpMachineName, LPCSTR lpDatabaseName, DWORD dwDesiredAccess)
Definition: scm.c:1972
#define FALSE
Definition: types.h:117
DWORD WINAPI RGetServiceKeyNameW(SC_RPC_HANDLE hSCManager, LPCWSTR lpDisplayName, LPWSTR lpServiceName, DWORD *lpcchBuffer)
Definition: rpcserver.c:3380
#define UNICODE_NULL
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD SECURITY_INFORMATION
Definition: ms-dtyp.idl:311
DWORD WINAPI RQueryServiceConfig2W(SC_RPC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
Definition: rpcserver.c:5799
#define debugstr_w
Definition: kernel32.h:32
#define FIXME(fmt,...)
Definition: debug.h:111
BOOL WINAPI ChangeServiceConfigW(SC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName, LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCWSTR lpDependencies, LPCWSTR lpServiceStartName, LPCWSTR lpPassword, LPCWSTR lpDisplayName)
Definition: scm.c:482
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
WINE_DEFAULT_DEBUG_CHANNEL(advapi)
#define RpcTryExcept
Definition: rpc.h:126
SC_HANDLE WINAPI OpenServiceW(SC_HANDLE hSCManager, LPCWSTR lpServiceName, DWORD dwDesiredAccess)
Definition: scm.c:2108
DWORD WINAPI REnumServiceGroupW(SC_RPC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeIndex, LPCWSTR pszGroupName)
Definition: rpcserver.c:4753
unsigned char * RPC_CSTR
Definition: rpcdce.h:45
BOOL WINAPI CloseServiceHandle(SC_HANDLE hSCObject)
Definition: scm.c:580
#define RPC_S_INVALID_BINDING
Definition: winerror.h:1013
PVOID pBuffer
void __RPC_USER SVCCTL_HANDLEA_unbind(SVCCTL_HANDLEA szMachineName, handle_t hBinding)
Definition: scm.c:72
BOOL WINAPI QueryServiceConfig2A(SC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2322
#define _In_
Definition: ms_sal.h:308
DWORD WINAPI RStartServiceW(SC_RPC_HANDLE hService, DWORD argc, LPSTRING_PTRSW argv)
Definition: rpcserver.c:3254
struct _ENUM_SERVICE_STATUS_PROCESSA ENUM_SERVICE_STATUS_PROCESSA
const char * LPCSTR
Definition: xmlstorage.h:183
DWORD WINAPI RNotifyBootConfigStatus(SVCCTL_HANDLEW lpMachineName, DWORD BootAcceptable)
Definition: rpcserver.c:1849
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
DWORD WINAPI RQueryServiceConfig2A(SC_RPC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
Definition: rpcserver.c:5552
#define __RPC_USER
Definition: rpc.h:65
DWORD WINAPI RQueryServiceStatus(SC_RPC_HANDLE hService, LPSERVICE_STATUS lpServiceStatus)
Definition: rpcserver.c:1608
BOOL WINAPI StartServiceA(SC_HANDLE hService, DWORD dwNumServiceArgs, LPCSTR *lpServiceArgVectors)
Definition: scm.c:2890
static LPSTR lpNameBuffer
Definition: secur32.c:50
NTSTATUS WINAPI SystemFunction028(IN PVOID ContextHandle, OUT LPBYTE SessionKey)
Status
Definition: gdiplustypes.h:24
BOOL WINAPI EnumDependentServicesW(SC_HANDLE hService, DWORD dwServiceState, LPENUM_SERVICE_STATUSW lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned)
Definition: scm.c:1033
#define RpcExceptionCode()
Definition: rpc.h:132
BOOL WINAPI StartServiceW(SC_HANDLE hService, DWORD dwNumServiceArgs, LPCWSTR *lpServiceArgVectors)
Definition: scm.c:2928
#define TRACE(s)
Definition: solgame.cpp:4
struct _QUERY_SERVICE_LOCK_STATUSW QUERY_SERVICE_LOCK_STATUSW
BOOL WINAPI QueryServiceLockStatusW(SC_HANDLE hSCManager, LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2618
#define GetProcessHeap()
Definition: compat.h:595
enum _SC_ENUM_TYPE SC_ENUM_TYPE
Definition: service.c:43
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
struct _SERVICE_DESCRIPTIONW * LPSERVICE_DESCRIPTIONW
RPC_STATUS WINAPI RpcBindingFromStringBindingA(RPC_CSTR StringBinding, RPC_BINDING_HANDLE *Binding)
Definition: rpc_binding.c:836
struct _ENUM_SERVICE_STATUS_PROCESSA * LPENUM_SERVICE_STATUS_PROCESSA
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define debugstr_a
Definition: kernel32.h:31
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
BOOL WINAPI EnumServicesStatusExA(SC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle, LPCSTR pszGroupName)
Definition: scm.c:1410
BOOL WINAPI ChangeServiceConfigA(SC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpBinaryPathName, LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCSTR lpDependencies, LPCSTR lpServiceStartName, LPCSTR lpPassword, LPCSTR lpDisplayName)
Definition: scm.c:363
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
static SERVICE_STATUS ServiceStatus
Definition: browser.c:22
DWORD WINAPI RGetServiceDisplayNameA(SC_RPC_HANDLE hSCManager, LPCSTR lpServiceName, LPSTR lpDisplayName, LPBOUNDED_DWORD_4K lpcchBuffer)
Definition: rpcserver.c:4460
#define WINAPI
Definition: msvc.h:6
struct _SERVICE_FAILURE_ACTIONSW SERVICE_FAILURE_ACTIONSW
#define SERVICE_CONFIG_FAILURE_ACTIONS
Definition: winsvc.h:66
DWORD WINAPI ROpenServiceW(SC_RPC_HANDLE hSCManager, LPWSTR lpServiceName, DWORD dwDesiredAccess, LPSC_RPC_HANDLE lpServiceHandle)
Definition: rpcserver.c:2920
static FILE * out
Definition: regtests2xml.c:44
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ DWORD _In_ DWORD cbBufSize
Definition: winsvc.h:424
BOOL WINAPI QueryServiceStatus(SC_HANDLE hService, LPSERVICE_STATUS lpServiceStatus)
Definition: scm.c:2793
#define SetLastError(x)
Definition: compat.h:611
LPSTR SVCCTL_HANDLEA
Definition: svcctl.idl:18
NTSTATUS WINAPI SystemFunction004(const struct ustring *in, const struct ustring *key, struct ustring *out)
Definition: sysfunc.c:119
DWORD WINAPI RCreateServiceA(SC_RPC_HANDLE hSCManager, LPSTR lpServiceName, LPSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPSTR lpBinaryPathName, LPSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPBYTE lpDependencies, DWORD dwDependSize, LPSTR lpServiceStartName, LPBYTE lpPassword, DWORD dwPwSize, LPSC_RPC_HANDLE lpServiceHandle)
Definition: rpcserver.c:3592
struct _ENUM_SERVICE_STATUSW ENUM_SERVICE_STATUSW
LPWSTR lpDescription
Definition: winsvc.h:196
#define ERROR_INVALID_ADDRESS
Definition: compat.h:106
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
struct _ENUM_SERVICE_STATUS_PROCESSW * LPENUM_SERVICE_STATUS_PROCESSW
#define RPC_X_ENUM_VALUE_OUT_OF_RANGE
Definition: winerror.h:1088
static const WCHAR L[]
Definition: oid.c:1250
DWORD WINAPI RI_ScQueryServiceTagInfo(SC_RPC_HANDLE hSCManager, TAG_INFO_LEVEL dwInfoLevel, PTAG_INFO_NAME_FROM_TAG_IN_PARAMS *lpInParams, PTAG_INFO_NAME_FROM_TAG_OUT_PARAMS *lpOutParams)
Definition: rpcserver.c:6593
SC_HANDLE WINAPI OpenSCManagerW(LPCWSTR lpMachineName, LPCWSTR lpDatabaseName, DWORD dwDesiredAccess)
Definition: scm.c:2016
BOOL WINAPI QueryServiceConfig2W(SC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2439
BOOL WINAPI EnumDependentServicesA(SC_HANDLE hService, DWORD dwServiceState, LPENUM_SERVICE_STATUSA lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned)
Definition: scm.c:955
static const WCHAR Cleanup[]
Definition: register.c:80
#define SYNCHRONIZE
Definition: nt_native.h:61
DWORD WINAPI RCloseServiceHandle(LPSC_RPC_HANDLE hSCObject)
Definition: rpcserver.c:936
_In_ DWORD dwInfoLevel
Definition: winsvc.h:422
SC_HANDLE hSCManager
Definition: sc.c:12
#define ERROR_MORE_DATA
Definition: dderror.h:13
unsigned char BYTE
Definition: xxhash.c:193
struct _QUERY_SERVICE_LOCK_STATUSA QUERY_SERVICE_LOCK_STATUSA
DWORD WINAPI RSetServiceObjectSecurity(SC_RPC_HANDLE hService, DWORD dwSecurityInformation, LPBYTE lpSecurityDescriptor, DWORD dwSecurityDescriptorSize)
Definition: rpcserver.c:1474
struct _SERVICE_DESCRIPTIONA SERVICE_DESCRIPTIONA
#define ERROR_INVALID_DATA
Definition: winerror.h:116
DWORD WINAPI RChangeServiceConfig2W(SC_RPC_HANDLE hService, SC_RPC_CONFIG_INFOW Info)
Definition: rpcserver.c:5420
DWORD WINAPI REnumServicesStatusW(SC_RPC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD dwBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeHandle)
Definition: rpcserver.c:2842
#define ERR(fmt,...)
Definition: debug.h:110
BOOL WINAPI GetServiceDisplayNameW(SC_HANDLE hSCManager, LPCWSTR lpServiceName, LPWSTR lpDisplayName, LPDWORD lpcchBuffer)
Definition: scm.c:1684
DWORD WINAPI ROpenSCManagerA(LPSTR lpMachineName, LPSTR lpDatabaseName, DWORD dwDesiredAccess, LPSC_RPC_HANDLE lpScHandle)
Definition: rpcserver.c:4006
ULONG_PTR SIZE_T
Definition: typedefs.h:80
SC_ACTION * lpsaActions
Definition: winsvc.h:213
DWORD WINAPI RQueryServiceLockStatusA(SC_RPC_HANDLE hSCManager, LPBYTE lpBuf, DWORD cbBufSize, LPBOUNDED_DWORD_4K pcbBytesNeeded)
Definition: rpcserver.c:4315
#define ERROR_INVALID_SERVICE_LOCK
Definition: winerror.h:622
GLuint in
Definition: glext.h:9616
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
LPWSTR lpServiceName
Definition: winsvc.h:130
LPWSTR lpDisplayName
Definition: winsvc.h:131
#define ERROR_RETRY
Definition: winerror.h:740
BOOL WINAPI ControlService(SC_HANDLE hService, DWORD dwControl, LPSERVICE_STATUS lpServiceStatus)
Definition: scm.c:622
struct _SERVICE_FAILURE_ACTIONSW * LPSERVICE_FAILURE_ACTIONSW
Definition: config.c:18
#define NULL
Definition: types.h:112
SC_LOCK WINAPI LockServiceDatabase(SC_HANDLE hSCManager)
Definition: scm.c:1906
BOOL WINAPI SetServiceObjectSecurity(SC_HANDLE hService, SECURITY_INFORMATION dwSecurityInformation, PSECURITY_DESCRIPTOR lpSecurityDescriptor)
Definition: scm.c:2722
DWORD WINAPI RLockServiceDatabase(SC_RPC_HANDLE hSCManager, LPSC_RPC_LOCK lpLock)
Definition: rpcserver.c:1362
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
BOOL WINAPI ControlServiceEx(IN SC_HANDLE hService, IN DWORD dwControl, IN DWORD dwInfoLevel, IN OUT PVOID pControlParams)
Definition: scm.c:662
DWORD * PDWORD
Definition: pedump.c:68
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
LPWSTR lpServiceStartName
Definition: winsvc.h:163
#define MultiByteToWideChar
Definition: compat.h:110
SC_HANDLE WINAPI OpenServiceA(SC_HANDLE hSCManager, LPCSTR lpServiceName, DWORD dwDesiredAccess)
Definition: scm.c:2060
struct _ENUM_SERVICE_STATUS_PROCESSW ENUM_SERVICE_STATUS_PROCESSW
#define OUT
Definition: typedefs.h:40
BOOL WINAPI GetServiceKeyNameA(SC_HANDLE hSCManager, LPCSTR lpDisplayName, LPSTR lpServiceName, LPDWORD lpcchBuffer)
Definition: scm.c:1747
uint32_t * LPDWORD
Definition: typedefs.h:59
DWORD WINAPI I_QueryTagInformation(PVOID Unused, TAG_INFO_LEVEL dwInfoLevel, PTAG_INFO_NAME_FROM_TAG InOutParams)
Definition: scm.c:3132
handle_t __RPC_USER SVCCTL_HANDLEW_bind(SVCCTL_HANDLEW szMachineName)
Definition: scm.c:89
BOOL WINAPI QueryServiceLockStatusA(SC_HANDLE hSCManager, LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2556
unsigned int ULONG
Definition: retypes.h:1
#define LPTR
Definition: winbase.h:378
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102
#define ULONG_PTR
Definition: config.h:101
LPWSTR lpBinaryPathName
Definition: winsvc.h:159
DWORD WINAPI REnumDependentServicesA(SC_RPC_HANDLE hService, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned)
Definition: rpcserver.c:3745
DWORD WINAPI ROpenServiceA(SC_RPC_HANDLE hSCManager, LPSTR lpServiceName, DWORD dwDesiredAccess, LPSC_RPC_HANDLE lpServiceHandle)
Definition: rpcserver.c:4044
DWORD WINAPI RControlService(SC_RPC_HANDLE hService, DWORD dwControl, LPSERVICE_STATUS lpServiceStatus)
Definition: rpcserver.c:1069
DWORD WINAPI RQueryServiceLockStatusW(SC_RPC_HANDLE hSCManager, LPBYTE lpBuf, DWORD cbBufSize, LPBOUNDED_DWORD_4K pcbBytesNeeded)
Definition: rpcserver.c:3211
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1373
DWORD WINAPI RQueryServiceStatusEx(SC_RPC_HANDLE hService, SC_STATUS_TYPE InfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
Definition: rpcserver.c:6023
DWORD WINAPI RUnlockServiceDatabase(LPSC_RPC_LOCK Lock)
Definition: rpcserver.c:1838
#define ERROR_INVALID_LEVEL
Definition: winerror.h:196
DWORD WINAPI RQueryServiceConfigA(SC_RPC_HANDLE hService, LPBYTE lpBuf, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
Definition: rpcserver.c:4074
WCHAR * LPWSTR
Definition: xmlstorage.h:184
BOOL WINAPI ChangeServiceConfig2W(SC_HANDLE hService, DWORD dwInfoLevel, LPVOID lpInfo)
Definition: scm.c:305
#define SCM_START_EVENT
Definition: services.h:26
struct _ENUM_SERVICE_STATUSA ENUM_SERVICE_STATUSA
DWORD WINAPI RGetServiceKeyNameA(SC_RPC_HANDLE hSCManager, LPCSTR lpDisplayName, LPSTR lpServiceName, LPBOUNDED_DWORD_4K lpcchBuffer)
Definition: rpcserver.c:4582
NTSYSAPI NTSTATUS NTAPI RtlMakeSelfRelativeSD(_In_ PSECURITY_DESCRIPTOR AbsoluteSD, _Out_ PSECURITY_DESCRIPTOR SelfRelativeSD, _Inout_ PULONG BufferLength)
#define CHAR(Char)
DWORD WINAPI RI_ScGetCurrentGroupStateW(SC_RPC_HANDLE hSCManager, LPWSTR lpLoadOrderGroup, LPDWORD lpState)
Definition: rpcserver.c:4696
static SERVICE_STATUS status
Definition: service.c:31
BOOL WINAPI EnumServicesStatusExW(SC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle, LPCWSTR pszGroupName)
Definition: scm.c:1518
_In_ LPCSTR _Out_writes_to_opt_ cchDisplayName LPSTR lpDisplayName
Definition: winbase.h:2769
DWORD WINAPI RChangeServiceConfig2A(SC_RPC_HANDLE hService, SC_RPC_CONFIG_INFOA Info)
Definition: rpcserver.c:5019
BYTE * PBYTE
Definition: pedump.c:66
struct _SC_ACTION * LPSC_ACTION
LPWSTR SVCCTL_HANDLEW
Definition: svcctl.idl:19
#define HeapFree(x, y, z)
Definition: compat.h:594
struct _SERVICE_FAILURE_ACTIONSA * LPSERVICE_FAILURE_ACTIONSA
enum _TAG_INFO_LEVEL TAG_INFO_LEVEL
unsigned char * Buffer
Definition: config.c:22
DWORD WINAPI RChangeServiceConfigW(SC_RPC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPWSTR lpBinaryPathName, LPWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPBYTE lpDependencies, DWORD dwDependSize, LPWSTR lpServiceStartName, LPBYTE lpPassword, DWORD dwPwSize, LPWSTR lpDisplayName)
Definition: rpcserver.c:1920
BOOL WINAPI QueryServiceObjectSecurity(SC_HANDLE hService, SECURITY_INFORMATION dwSecurityInformation, PSECURITY_DESCRIPTOR lpSecurityDescriptor, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2680
#define RPC_S_OK
Definition: rpcnterr.h:22
#define RpcExcept(expr)
Definition: rpc.h:127
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
Definition: path.c:41
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
Definition: ps.c:97