reactos/lib/advapi32/service/scm.c

   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  * UPDATE HISTORY:
   9  *  19990413 EA created
  10  *  19990515 EA
  11  */
  12
  13 /* INCLUDES ******************************************************************/
  14
  15 #include <advapi32.h>
  16 #include "svcctl_c.h"
  17
  18 #define NDEBUG
  19 #include <debug.h>
  20
  21 /* FUNCTIONS *****************************************************************/
  22
  23 handle_t BindingHandle = NULL;
  24
  25 static VOID
  26 HandleBind(VOID)
  27 {
  28     LPWSTR pszStringBinding;
  29     RPC_STATUS status;
  30
  31     if (BindingHandle != NULL)
  32         return;
  33
  34     status = RpcStringBindingComposeW(NULL,
  35                                       L"ncacn_np",
  36                                       NULL,
  37                                       L"\\pipe\\ntsvcs",
  38                                       NULL,
  39                                       &pszStringBinding);
  40     if (status)
  41     {
  42         DPRINT1("RpcStringBindingCompose returned 0x%x\n", status);
  43         return;
  44     }
  45
  46     /* Set the binding handle that will be used to bind to the server. */
  47     status = RpcBindingFromStringBindingW(pszStringBinding,
  48                                           &BindingHandle);
  49     if (status)
  50     {
  51         DPRINT1("RpcBindingFromStringBinding returned 0x%x\n", status);
  52     }
  53
  54     status = RpcStringFreeW(&pszStringBinding);
  55     if (status)
  56     {
  57         DPRINT1("RpcStringFree returned 0x%x\n", status);
  58     }
  59 }
  60
  61
  62 #if 0
  63 static VOID
  64 HandleUnbind(VOID)
  65 {
  66     RPC_STATUS status;
  67
  68     if (BindingHandle == NULL)
  69         return;
  70
  71     status = RpcBindingFree(&BindingHandle);
  72     if (status)
  73     {
  74         DPRINT1("RpcBindingFree returned 0x%x\n", status);
  75     }
  76 }
  77 #endif
  78
  79
  80 /**********************************************************************
  81  *  ChangeServiceConfigA
  82  *
  83  * @unimplemented
  84  */
  85 BOOL
  86 STDCALL
  87 ChangeServiceConfigA(
  88     SC_HANDLE   hService,
  89     DWORD       dwServiceType,
  90     DWORD       dwStartType,
  91     DWORD       dwErrorControl,
  92     LPCSTR      lpBinaryPathName,
  93     LPCSTR      lpLoadOrderGroup,
  94     LPDWORD     lpdwTagId,
  95     LPCSTR      lpDependencies,
  96     LPCSTR      lpServiceStartName,
  97     LPCSTR      lpPassword,
  98     LPCSTR      lpDisplayName)
  99 {
 100     DPRINT1("ChangeServiceConfigA is unimplemented\n");
 101     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 102     return FALSE;
 103 }
 104
 105
 106 /**********************************************************************
 107  *  ChangeServiceConfigW
 108  *
 109  * @implemented
 110  */
 111 BOOL STDCALL
 112 ChangeServiceConfigW(SC_HANDLE hService,
 113                      DWORD dwServiceType,
 114                      DWORD dwStartType,
 115                      DWORD dwErrorControl,
 116                      LPCWSTR lpBinaryPathName,
 117                      LPCWSTR lpLoadOrderGroup,
 118                      LPDWORD lpdwTagId,
 119                      LPCWSTR lpDependencies,
 120                      LPCWSTR lpServiceStartName,
 121                      LPCWSTR lpPassword,
 122                      LPCWSTR lpDisplayName)
 123 {
 124     DWORD dwError;
 125     DWORD dwDependenciesLength = 0;
 126     DWORD dwLength;
 127     LPWSTR lpStr;
 128
 129     DPRINT("ChangeServiceConfigW() called\n");
 130
 131     /* Calculate the Dependencies length*/
 132     if (lpDependencies != NULL)
 133     {
 134         lpStr = (LPWSTR)lpDependencies;
 135         while (*lpStr)
 136         {
 137             dwLength = wcslen(lpStr) + 1;
 138             dwDependenciesLength += dwLength;
 139             lpStr = lpStr + dwLength;
 140         }
 141         dwDependenciesLength++;
 142     }
 143
 144     /* FIXME: Encrypt the password */
 145
 146     HandleBind();
 147
 148     /* Call to services.exe using RPC */
 149     dwError = ScmrChangeServiceConfigW(BindingHandle,
 150                                        (unsigned int)hService,
 151                                        dwServiceType,
 152                                        dwStartType,
 153                                        dwErrorControl,
 154                                        (LPWSTR)lpBinaryPathName,
 155                                        (LPWSTR)lpLoadOrderGroup,
 156                                        lpdwTagId,
 157                                        (LPWSTR)lpDependencies,
 158                                        dwDependenciesLength,
 159                                        (LPWSTR)lpServiceStartName,
 160                                        NULL,              /* FIXME: lpPassword */
 161                                        0,                 /* FIXME: dwPasswordLength */
 162                                        (LPWSTR)lpDisplayName);
 163     if (dwError != ERROR_SUCCESS)
 164     {
 165         DPRINT1("ScmrChangeServiceConfigW() failed (Error %lu)\n", dwError);
 166         SetLastError(dwError);
 167         return FALSE;
 168     }
 169
 170     return TRUE;
 171 }
 172
 173
 174 /**********************************************************************
 175  *  CloseServiceHandle
 176  *
 177  * @implemented
 178  */
 179 BOOL STDCALL
 180 CloseServiceHandle(SC_HANDLE hSCObject)
 181 {
 182     DWORD dwError;
 183
 184     DPRINT("CloseServiceHandle() called\n");
 185
 186     HandleBind();
 187
 188     /* Call to services.exe using RPC */
 189     dwError = ScmrCloseServiceHandle(BindingHandle,
 190                                      (unsigned int)hSCObject);
 191     if (dwError)
 192     {
 193         DPRINT1("ScmrCloseServiceHandle() failed (Error %lu)\n", dwError);
 194         SetLastError(dwError);
 195         return FALSE;
 196     }
 197
 198     DPRINT("CloseServiceHandle() done\n");
 199
 200     return TRUE;
 201 }
 202
 203
 204 /**********************************************************************
 205  *  ControlService
 206  *
 207  * @unimplemented
 208  */
 209 BOOL STDCALL
 210 ControlService(SC_HANDLE hService,
 211                DWORD dwControl,
 212                LPSERVICE_STATUS lpServiceStatus)
 213 {
 214     DWORD dwError;
 215
 216     DPRINT("ControlService(%x, %x, %p)\n",
 217            hService, dwControl, lpServiceStatus);
 218
 219     HandleBind();
 220
 221     /* Call to services.exe using RPC */
 222     dwError = ScmrControlService(BindingHandle,
 223                                  (unsigned int)hService,
 224                                  dwControl,
 225                                  lpServiceStatus);
 226     if (dwError != ERROR_SUCCESS)
 227     {
 228         DPRINT1("ScmrControlService() failed (Error %lu)\n", dwError);
 229         SetLastError(dwError);
 230         return FALSE;
 231     }
 232
 233     DPRINT("ControlService() done\n");
 234
 235     return TRUE;
 236 }
 237
 238
 239 /**********************************************************************
 240  *  ControlServiceEx
 241  *
 242  * @unimplemented
 243  */
 244 BOOL STDCALL
 245 ControlServiceEx(IN SC_HANDLE hService,
 246                  IN DWORD dwControl,
 247                  IN DWORD dwInfoLevel,
 248                  IN OUT PVOID pControlParams)
 249 {
 250     DPRINT1("ControlServiceEx(0x%p, 0x%x, 0x%x, 0x%p) UNIMPLEMENTED!\n",
 251             hService, dwControl, dwInfoLevel, pControlParams);
 252     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 253     return FALSE;
 254 }
 255
 256
 257
 258 /**********************************************************************
 259  *  CreateServiceA
 260  *
 261  * @implemented
 262  */
 263 SC_HANDLE
 264 STDCALL
 265 CreateServiceA(
 266     SC_HANDLE   hSCManager,
 267     LPCSTR      lpServiceName,
 268     LPCSTR      lpDisplayName,
 269     DWORD       dwDesiredAccess,
 270     DWORD       dwServiceType,
 271     DWORD       dwStartType,
 272     DWORD       dwErrorControl,
 273     LPCSTR      lpBinaryPathName,
 274     LPCSTR      lpLoadOrderGroup,
 275     LPDWORD     lpdwTagId,
 276     LPCSTR      lpDependencies,
 277     LPCSTR      lpServiceStartName,
 278     LPCSTR      lpPassword)
 279 {
 280     SC_HANDLE RetVal = NULL;
 281     LPWSTR lpServiceNameW = NULL;
 282     LPWSTR lpDisplayNameW = NULL;
 283     LPWSTR lpBinaryPathNameW = NULL;
 284     LPWSTR lpLoadOrderGroupW = NULL;
 285     LPWSTR lpDependenciesW = NULL;
 286     LPWSTR lpServiceStartNameW = NULL;
 287     LPWSTR lpPasswordW = NULL;
 288
 289     int len = MultiByteToWideChar(CP_ACP, 0, lpServiceName, -1, NULL, 0);
 290     lpServiceNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 291     if (!lpServiceNameW)
 292     {
 293         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 294         goto cleanup;
 295     }
 296     MultiByteToWideChar(CP_ACP, 0, lpServiceName, -1, lpServiceNameW, len);
 297
 298     len = MultiByteToWideChar(CP_ACP, 0, lpDisplayName, -1, NULL, 0);
 299     lpDisplayNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 300     if (!lpDisplayNameW)
 301     {
 302         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 303         goto cleanup;
 304     }
 305     MultiByteToWideChar(CP_ACP, 0, lpDisplayName, -1, lpDisplayNameW, len);
 306
 307     len = MultiByteToWideChar(CP_ACP, 0, lpBinaryPathName, -1, NULL, 0);
 308     lpBinaryPathNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 309     if (!lpBinaryPathNameW)
 310     {
 311         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 312         goto cleanup;
 313     }
 314     MultiByteToWideChar(CP_ACP, 0, lpDisplayName, -1, lpBinaryPathNameW, len);
 315
 316     len = MultiByteToWideChar(CP_ACP, 0, lpLoadOrderGroup, -1, NULL, 0);
 317     lpLoadOrderGroupW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 318     if (!lpLoadOrderGroupW)
 319     {
 320         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 321         goto cleanup;
 322     }
 323     MultiByteToWideChar(CP_ACP, 0, lpLoadOrderGroup, -1, lpLoadOrderGroupW, len);
 324
 325     len = MultiByteToWideChar(CP_ACP, 0, lpDependencies, -1, NULL, 0);
 326     lpDependenciesW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 327     if (!lpDependenciesW)
 328     {
 329         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 330         goto cleanup;
 331     }
 332     MultiByteToWideChar(CP_ACP, 0, lpDependencies, -1, lpDependenciesW, len);
 333
 334     len = MultiByteToWideChar(CP_ACP, 0, lpServiceStartName, -1, NULL, 0);
 335     lpServiceStartName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 336     if (!lpServiceStartNameW)
 337     {
 338         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 339         goto cleanup;
 340     }
 341     MultiByteToWideChar(CP_ACP, 0, lpServiceStartName, -1, lpServiceStartNameW, len);
 342
 343     len = MultiByteToWideChar(CP_ACP, 0, lpPassword, -1, NULL, 0);
 344     lpPasswordW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 345     if (!lpPasswordW)
 346     {
 347         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 348         goto cleanup;
 349     }
 350     MultiByteToWideChar(CP_ACP, 0, lpPassword, -1, lpPasswordW, len);
 351
 352     RetVal = CreateServiceW(hSCManager,
 353                    lpServiceNameW,
 354                    lpDisplayNameW,
 355                    dwDesiredAccess,
 356                    dwServiceType,
 357                    dwStartType,
 358                    dwErrorControl,
 359                    lpBinaryPathNameW,
 360                    lpLoadOrderGroupW,
 361                    lpdwTagId,
 362                    lpDependenciesW,
 363                    lpServiceStartNameW,
 364                    lpPasswordW);
 365
 366
 367 cleanup:
 368     if (!lpServiceNameW) HeapFree(GetProcessHeap(), 0, lpServiceNameW);
 369     if (!lpDisplayNameW) HeapFree(GetProcessHeap(), 0, lpDisplayNameW);
 370     if (!lpBinaryPathNameW) HeapFree(GetProcessHeap(), 0, lpBinaryPathNameW);
 371     if (!lpLoadOrderGroupW) HeapFree(GetProcessHeap(), 0, lpLoadOrderGroupW);
 372     if (!lpDependenciesW) HeapFree(GetProcessHeap(), 0, lpDependenciesW);
 373     if (!lpServiceStartNameW) HeapFree(GetProcessHeap(), 0, lpServiceStartNameW);
 374     if (!lpPasswordW) HeapFree(GetProcessHeap(), 0, lpPasswordW);
 375
 376     return RetVal;
 377 }
 378
 379
 380 /**********************************************************************
 381  *  CreateServiceW
 382  *
 383  * @implemented
 384  */
 385 SC_HANDLE STDCALL
 386 CreateServiceW(SC_HANDLE hSCManager,
 387                LPCWSTR lpServiceName,
 388                LPCWSTR lpDisplayName,
 389                DWORD dwDesiredAccess,
 390                DWORD dwServiceType,
 391                DWORD dwStartType,
 392                DWORD dwErrorControl,
 393                LPCWSTR lpBinaryPathName,
 394                LPCWSTR lpLoadOrderGroup,
 395                LPDWORD lpdwTagId,
 396                LPCWSTR lpDependencies,
 397                LPCWSTR lpServiceStartName,
 398                LPCWSTR lpPassword)
 399 {
 400     SC_HANDLE hService = NULL;
 401     DWORD dwError;
 402     DWORD dwDependenciesLength = 0;
 403     DWORD dwLength;
 404     LPWSTR lpStr;
 405
 406     DPRINT1("CreateServiceW() called\n");
 407
 408     /* Calculate the Dependencies length*/
 409     if (lpDependencies != NULL)
 410     {
 411         lpStr = (LPWSTR)lpDependencies;
 412         while (*lpStr)
 413         {
 414             dwLength = wcslen(lpStr) + 1;
 415             dwDependenciesLength += dwLength;
 416             lpStr = lpStr + dwLength;
 417         }
 418         dwDependenciesLength++;
 419     }
 420
 421     /* FIXME: Encrypt the password */
 422
 423     HandleBind();
 424
 425     /* Call to services.exe using RPC */
 426     dwError = ScmrCreateServiceW(BindingHandle,
 427                                  (unsigned int)hSCManager,
 428                                  (LPWSTR)lpServiceName,
 429                                  (LPWSTR)lpDisplayName,
 430                                  dwDesiredAccess,
 431                                  dwServiceType,
 432                                  dwStartType,
 433                                  dwErrorControl,
 434                                  (LPWSTR)lpBinaryPathName,
 435                                  (LPWSTR)lpLoadOrderGroup,
 436                                  lpdwTagId,
 437                                  (LPWSTR)lpDependencies,
 438                                  dwDependenciesLength,
 439                                  (LPWSTR)lpServiceStartName,
 440                                  NULL,              /* FIXME: lpPassword */
 441                                  0,                 /* FIXME: dwPasswordLength */
 442                                  (unsigned int *)&hService);
 443     if (dwError != ERROR_SUCCESS)
 444     {
 445         DPRINT1("ScmrCreateServiceW() failed (Error %lu)\n", dwError);
 446         SetLastError(dwError);
 447         return INVALID_HANDLE_VALUE;
 448     }
 449
 450     return hService;
 451 }
 452
 453
 454 /**********************************************************************
 455  *  DeleteService
 456  *
 457  * @implemented
 458  */
 459 BOOL STDCALL
 460 DeleteService(SC_HANDLE hService)
 461 {
 462     DWORD dwError;
 463
 464     DPRINT("DeleteService(%x)\n", hService);
 465
 466     HandleBind();
 467
 468     /* Call to services.exe using RPC */
 469     dwError = ScmrDeleteService(BindingHandle,
 470                                 (unsigned int)hService);
 471     if (dwError != ERROR_SUCCESS)
 472     {
 473         DPRINT1("ScmrDeleteService() failed (Error %lu)\n", dwError);
 474         SetLastError(dwError);
 475         return FALSE;
 476     }
 477
 478     return TRUE;
 479 }
 480
 481
 482 /**********************************************************************
 483  *  EnumDependentServicesA
 484  *
 485  * @unimplemented
 486  */
 487 BOOL
 488 STDCALL
 489 EnumDependentServicesA(
 490     SC_HANDLE       hService,
 491     DWORD           dwServiceState,
 492     LPENUM_SERVICE_STATUSA  lpServices,
 493     DWORD           cbBufSize,
 494     LPDWORD         pcbBytesNeeded,
 495     LPDWORD         lpServicesReturned)
 496 {
 497     DPRINT1("EnumDependentServicesA is unimplemented\n");
 498     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 499     return FALSE;
 500 }
 501
 502
 503 /**********************************************************************
 504  *  EnumDependentServicesW
 505  *
 506  * @unimplemented
 507  */
 508 BOOL
 509 STDCALL
 510 EnumDependentServicesW(
 511     SC_HANDLE       hService,
 512     DWORD           dwServiceState,
 513     LPENUM_SERVICE_STATUSW  lpServices,
 514     DWORD           cbBufSize,
 515     LPDWORD         pcbBytesNeeded,
 516     LPDWORD         lpServicesReturned)
 517 {
 518     DPRINT1("EnumDependentServicesW is unimplemented\n");
 519     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 520     return FALSE;
 521 }
 522
 523
 524 /**********************************************************************
 525  *  EnumServiceGroupW
 526  *
 527  * @unimplemented
 528  */
 529 BOOL
 530 STDCALL
 531 EnumServiceGroupW (
 532     DWORD   Unknown0,
 533     DWORD   Unknown1,
 534     DWORD   Unknown2,
 535     DWORD   Unknown3,
 536     DWORD   Unknown4,
 537     DWORD   Unknown5,
 538     DWORD   Unknown6,
 539     DWORD   Unknown7,
 540     DWORD   Unknown8)
 541 {
 542     DPRINT1("EnumServiceGroupW is unimplemented\n");
 543     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 544     return FALSE;
 545 }
 546
 547
 548 /**********************************************************************
 549  *  EnumServicesStatusA
 550  *
 551  * @unimplemented
 552  */
 553 BOOL
 554 STDCALL
 555 EnumServicesStatusA (
 556     SC_HANDLE               hSCManager,
 557     DWORD                   dwServiceType,
 558     DWORD                   dwServiceState,
 559     LPENUM_SERVICE_STATUSA  lpServices,
 560     DWORD                   cbBufSize,
 561     LPDWORD                 pcbBytesNeeded,
 562     LPDWORD                 lpServicesReturned,
 563     LPDWORD                 lpResumeHandle)
 564 {
 565     DPRINT1("EnumServicesStatusA is unimplemented\n");
 566     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 567     return FALSE;
 568 }
 569
 570
 571 /**********************************************************************
 572  *  EnumServicesStatusExA
 573  *
 574  * @unimplemented
 575  */
 576 BOOL
 577 STDCALL
 578 EnumServicesStatusExA(SC_HANDLE  hSCManager,
 579   SC_ENUM_TYPE  InfoLevel,
 580   DWORD  dwServiceType,
 581   DWORD  dwServiceState,
 582   LPBYTE  lpServices,
 583   DWORD  cbBufSize,
 584   LPDWORD  pcbBytesNeeded,
 585   LPDWORD  lpServicesReturned,
 586   LPDWORD  lpResumeHandle,
 587   LPCSTR  pszGroupName)
 588 {
 589     DPRINT1("EnumServicesStatusExA is unimplemented\n");
 590     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 591     return FALSE;
 592 }
 593
 594
 595 /**********************************************************************
 596  *  EnumServicesStatusExW
 597  *
 598  * @unimplemented
 599  */
 600 BOOL
 601 STDCALL
 602 EnumServicesStatusExW(SC_HANDLE  hSCManager,
 603   SC_ENUM_TYPE  InfoLevel,
 604   DWORD  dwServiceType,
 605   DWORD  dwServiceState,
 606   LPBYTE  lpServices,
 607   DWORD  cbBufSize,
 608   LPDWORD  pcbBytesNeeded,
 609   LPDWORD  lpServicesReturned,
 610   LPDWORD  lpResumeHandle,
 611   LPCWSTR  pszGroupName)
 612 {
 613     DPRINT1("EnumServicesStatusExW is unimplemented\n");
 614     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 615     return FALSE;
 616 }
 617
 618
 619 /**********************************************************************
 620  *  EnumServicesStatusW
 621  *
 622  * @unimplemented
 623  */
 624 BOOL
 625 STDCALL
 626 EnumServicesStatusW(
 627     SC_HANDLE               hSCManager,
 628     DWORD                   dwServiceType,
 629     DWORD                   dwServiceState,
 630     LPENUM_SERVICE_STATUSW  lpServices,
 631     DWORD                   cbBufSize,
 632     LPDWORD                 pcbBytesNeeded,
 633     LPDWORD                 lpServicesReturned,
 634     LPDWORD                 lpResumeHandle)
 635 {
 636     DPRINT1("EnumServicesStatusW is unimplemented\n");
 637     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 638     return FALSE;
 639 }
 640
 641
 642 /**********************************************************************
 643  *  GetServiceDisplayNameA
 644  *
 645  * @unimplemented
 646  */
 647 BOOL
 648 STDCALL
 649 GetServiceDisplayNameA(
 650     SC_HANDLE   hSCManager,
 651     LPCSTR      lpServiceName,
 652     LPSTR       lpDisplayName,
 653     LPDWORD     lpcchBuffer)
 654 {
 655     DPRINT1("GetServiceDisplayNameA is unimplemented\n");
 656     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 657     return FALSE;
 658 }
 659
 660
 661 /**********************************************************************
 662  *  GetServiceDisplayNameW
 663  *
 664  * @implemented
 665  */
 666 BOOL STDCALL
 667 GetServiceDisplayNameW(SC_HANDLE hSCManager,
 668                        LPCWSTR lpServiceName,
 669                        LPWSTR lpDisplayName,
 670                        LPDWORD lpcchBuffer)
 671 {
 672     DWORD dwError;
 673
 674     DPRINT("GetServiceDisplayNameW() called\n");
 675
 676     HandleBind();
 677
 678     dwError = ScmrGetServiceDisplayNameW(BindingHandle,
 679                                          (unsigned int)hSCManager,
 680                                          (LPWSTR)lpServiceName,
 681                                          lpDisplayName,
 682                                          lpcchBuffer);
 683     if (dwError != ERROR_SUCCESS)
 684     {
 685         DPRINT1("ScmrGetServiceDisplayNameW() failed (Error %lu)\n", dwError);
 686         SetLastError(dwError);
 687         return FALSE;
 688     }
 689
 690     (*lpcchBuffer)--;
 691
 692     return TRUE;
 693 }
 694
 695
 696 /**********************************************************************
 697  *  GetServiceKeyNameA
 698  *
 699  * @unimplemented
 700  */
 701 BOOL
 702 STDCALL
 703 GetServiceKeyNameA(
 704     SC_HANDLE   hSCManager,
 705     LPCSTR      lpDisplayName,
 706     LPSTR       lpServiceName,
 707     LPDWORD     lpcchBuffer)
 708 {
 709     DPRINT1("GetServiceKeyNameA is unimplemented\n");
 710     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 711     return FALSE;
 712 }
 713
 714
 715 /**********************************************************************
 716  *  GetServiceKeyNameW
 717  *
 718  * @implemented
 719  */
 720 BOOL STDCALL
 721 GetServiceKeyNameW(SC_HANDLE hSCManager,
 722                    LPCWSTR lpDisplayName,
 723                    LPWSTR lpServiceName,
 724                    LPDWORD lpcchBuffer)
 725 {
 726     DWORD dwError;
 727
 728     DPRINT("GetServiceKeyNameW() called\n");
 729
 730     HandleBind();
 731
 732     dwError = ScmrGetServiceKeyNameW(BindingHandle,
 733                                      (unsigned int)hSCManager,
 734                                      (LPWSTR)lpDisplayName,
 735                                      lpServiceName,
 736                                      lpcchBuffer);
 737     if (dwError != ERROR_SUCCESS)
 738     {
 739         DPRINT1("ScmrGetServiceKeyNameW() failed (Error %lu)\n", dwError);
 740         SetLastError(dwError);
 741         return FALSE;
 742     }
 743
 744     (*lpcchBuffer)--;
 745
 746     return TRUE;
 747 }
 748
 749
 750 /**********************************************************************
 751  *  LockServiceDatabase
 752  *
 753  * @implemented
 754  */
 755 SC_LOCK STDCALL
 756 LockServiceDatabase(SC_HANDLE hSCManager)
 757 {
 758     SC_LOCK hLock;
 759     DWORD dwError;
 760
 761     DPRINT("LockServiceDatabase(%x)\n", hSCManager);
 762
 763     HandleBind();
 764
 765     /* Call to services.exe using RPC */
 766     dwError = ScmrLockServiceDatabase(BindingHandle,
 767                                       (unsigned int)hSCManager,
 768                                       (unsigned int *)&hLock);
 769     if (dwError != ERROR_SUCCESS)
 770     {
 771         DPRINT1("ScmrLockServiceDatabase() failed (Error %lu)\n", dwError);
 772         SetLastError(dwError);
 773         return NULL;
 774     }
 775
 776     DPRINT("hLock = %p\n", hLock);
 777
 778     return hLock;
 779 }
 780
 781
 782 static VOID
 783 WaitForSCManager(VOID)
 784 {
 785     HANDLE hEvent;
 786
 787     DPRINT("WaitForSCManager() called\n");
 788
 789     /* Try to open the existing event */
 790     hEvent = OpenEventW(SYNCHRONIZE,
 791                         FALSE,
 792                         L"SvcctrlStartEvent_A3725DX");
 793     if (hEvent == NULL)
 794     {
 795         if (GetLastError() != ERROR_FILE_NOT_FOUND)
 796             return;
 797
 798         /* Try to create a new event */
 799         hEvent = CreateEventW(NULL,
 800                               TRUE,
 801                               FALSE,
 802                               L"SvcctrlStartEvent_A3725DX");
 803         if (hEvent == NULL)
 804         {
 805             /* Try to open the existing event again */
 806             hEvent = OpenEventW(SYNCHRONIZE,
 807                                 FALSE,
 808                                 L"SvcctrlStartEvent_A3725DX");
 809             if (hEvent == NULL)
 810                 return;
 811         }
 812     }
 813
 814     /* Wait for 3 minutes */
 815     WaitForSingleObject(hEvent, 180000);
 816     CloseHandle(hEvent);
 817
 818     DPRINT("ScmWaitForSCManager() done\n");
 819 }
 820
 821
 822 /**********************************************************************
 823  *  OpenSCManagerA
 824  *
 825  * @implemented
 826  */
 827 SC_HANDLE STDCALL
 828 OpenSCManagerA(LPCSTR lpMachineName,
 829                LPCSTR lpDatabaseName,
 830                DWORD dwDesiredAccess)
 831 {
 832     SC_HANDLE hScm = NULL;
 833     DWORD dwError;
 834
 835     DPRINT("OpenSCManagerA(%s, %s, %lx)\n",
 836            lpMachineName, lpDatabaseName, dwDesiredAccess);
 837
 838     WaitForSCManager();
 839
 840     HandleBind();
 841
 842     /* Call to services.exe using RPC */
 843     dwError = ScmrOpenSCManagerA(BindingHandle,
 844                                  (LPSTR)lpMachineName,
 845                                  (LPSTR)lpDatabaseName,
 846                                  dwDesiredAccess,
 847                                  (unsigned int*)&hScm);
 848     if (dwError != ERROR_SUCCESS)
 849     {
 850         DPRINT1("ScmrOpenSCManagerA() failed (Error %lu)\n", dwError);
 851         SetLastError(dwError);
 852         return NULL;
 853     }
 854
 855     DPRINT("hScm = %p\n", hScm);
 856
 857     return hScm;
 858 }
 859
 860
 861 /**********************************************************************
 862  *  OpenSCManagerW
 863  *
 864  * @implemented
 865  */
 866 SC_HANDLE STDCALL
 867 OpenSCManagerW(LPCWSTR lpMachineName,
 868                LPCWSTR lpDatabaseName,
 869                DWORD dwDesiredAccess)
 870 {
 871     SC_HANDLE hScm = NULL;
 872     DWORD dwError;
 873
 874     DPRINT("OpenSCManagerW(%S, %S, %lx)\n",
 875            lpMachineName, lpDatabaseName, dwDesiredAccess);
 876
 877     WaitForSCManager();
 878
 879     HandleBind();
 880
 881     /* Call to services.exe using RPC */
 882     dwError = ScmrOpenSCManagerW(BindingHandle,
 883                                  (LPWSTR)lpMachineName,
 884                                  (LPWSTR)lpDatabaseName,
 885                                  dwDesiredAccess,
 886                                  (unsigned int*)&hScm);
 887     if (dwError != ERROR_SUCCESS)
 888     {
 889         DPRINT1("ScmrOpenSCManagerW() failed (Error %lu)\n", dwError);
 890         SetLastError(dwError);
 891         return NULL;
 892     }
 893
 894     DPRINT("hScm = %p\n", hScm);
 895
 896     return hScm;
 897 }
 898
 899
 900 /**********************************************************************
 901  *  OpenServiceA
 902  *
 903  * @implemented
 904  */
 905 SC_HANDLE STDCALL
 906 OpenServiceA(SC_HANDLE hSCManager,
 907              LPCSTR lpServiceName,
 908              DWORD dwDesiredAccess)
 909 {
 910     SC_HANDLE hService = NULL;
 911     DWORD dwError;
 912
 913     DPRINT("OpenServiceA(%p, %s, %lx)\n",
 914            hSCManager, lpServiceName, dwDesiredAccess);
 915
 916     HandleBind();
 917
 918     /* Call to services.exe using RPC */
 919     dwError = ScmrOpenServiceA(BindingHandle,
 920                                (unsigned int)hSCManager,
 921                                (LPSTR)lpServiceName,
 922                                dwDesiredAccess,
 923                                (unsigned int*)&hService);
 924     if (dwError != ERROR_SUCCESS)
 925     {
 926         DPRINT1("ScmrOpenServiceA() failed (Error %lu)\n", dwError);
 927         SetLastError(dwError);
 928         return NULL;
 929     }
 930
 931     DPRINT("hService = %p\n", hService);
 932
 933     return hService;
 934 }
 935
 936
 937 /**********************************************************************
 938  *  OpenServiceW
 939  *
 940  * @implemented
 941  */
 942 SC_HANDLE STDCALL
 943 OpenServiceW(SC_HANDLE hSCManager,
 944              LPCWSTR lpServiceName,
 945              DWORD dwDesiredAccess)
 946 {
 947     SC_HANDLE hService = NULL;
 948     DWORD dwError;
 949
 950     DPRINT("OpenServiceW(%p, %S, %lx)\n",
 951            hSCManager, lpServiceName, dwDesiredAccess);
 952
 953     HandleBind();
 954
 955     /* Call to services.exe using RPC */
 956     dwError = ScmrOpenServiceW(BindingHandle,
 957                                (unsigned int)hSCManager,
 958                                (LPWSTR)lpServiceName,
 959                                dwDesiredAccess,
 960                                (unsigned int*)&hService);
 961     if (dwError != ERROR_SUCCESS)
 962     {
 963         DPRINT1("ScmrOpenServiceW() failed (Error %lu)\n", dwError);
 964         SetLastError(dwError);
 965         return NULL;
 966     }
 967
 968     DPRINT("hService = %p\n", hService);
 969
 970     return hService;
 971 }
 972
 973
 974 /**********************************************************************
 975  *  QueryServiceConfigA
 976  *
 977  * @unimplemented
 978  */
 979 BOOL
 980 STDCALL
 981 QueryServiceConfigA(
 982     SC_HANDLE       hService,
 983     LPQUERY_SERVICE_CONFIGA lpServiceConfig,
 984     DWORD           cbBufSize,
 985     LPDWORD         pcbBytesNeeded)
 986 {
 987     DPRINT1("QueryServiceConfigA is unimplemented\n");
 988     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 989     return FALSE;
 990 }
 991
 992
 993 /**********************************************************************
 994  *  QueryServiceConfigW
 995  *
 996  * @unimplemented
 997  */
 998 BOOL
 999 STDCALL
1000 QueryServiceConfigW(
1001     SC_HANDLE       hService,
1002     LPQUERY_SERVICE_CONFIGW lpServiceConfig,
1003     DWORD                   cbBufSize,
1004     LPDWORD                 pcbBytesNeeded)
1005 {
1006     DPRINT1("QueryServiceConfigW is unimplemented\n");
1007     if (lpServiceConfig && cbBufSize >= sizeof(QUERY_SERVICE_CONFIGW))
1008     {
1009         memset(lpServiceConfig, 0, *pcbBytesNeeded);
1010         return TRUE;
1011     }
1012     else
1013     {
1014         *pcbBytesNeeded = sizeof(QUERY_SERVICE_CONFIGW);
1015         SetLastError(ERROR_INSUFFICIENT_BUFFER);
1016         return FALSE;
1017     }
1018 }
1019
1020
1021 /**********************************************************************
1022  *  QueryServiceLockStatusA
1023  *
1024  * @unimplemented
1025  */
1026 BOOL
1027 STDCALL
1028 QueryServiceLockStatusA(
1029     SC_HANDLE           hSCManager,
1030     LPQUERY_SERVICE_LOCK_STATUSA    lpLockStatus,
1031     DWORD               cbBufSize,
1032     LPDWORD             pcbBytesNeeded)
1033 {
1034     DPRINT1("QueryServiceLockStatusA is unimplemented\n");
1035     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1036     return FALSE;
1037 }
1038
1039
1040 /**********************************************************************
1041  *  QueryServiceLockStatusW
1042  *
1043  * @unimplemented
1044  */
1045 BOOL
1046 STDCALL
1047 QueryServiceLockStatusW(
1048     SC_HANDLE           hSCManager,
1049     LPQUERY_SERVICE_LOCK_STATUSW    lpLockStatus,
1050     DWORD               cbBufSize,
1051     LPDWORD             pcbBytesNeeded)
1052 {
1053     DPRINT1("QueryServiceLockStatusW is unimplemented\n");
1054     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1055     return FALSE;
1056 }
1057
1058
1059 /**********************************************************************
1060  *  QueryServiceObjectSecurity
1061  *
1062  * @unimplemented
1063  */
1064 BOOL
1065 STDCALL
1066 QueryServiceObjectSecurity(
1067     SC_HANDLE       hService,
1068     SECURITY_INFORMATION    dwSecurityInformation,
1069     PSECURITY_DESCRIPTOR    lpSecurityDescriptor,
1070     DWORD           cbBufSize,
1071     LPDWORD         pcbBytesNeeded)
1072 {
1073     DPRINT1("QueryServiceObjectSecurity is unimplemented\n");
1074     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1075     return FALSE;
1076 }
1077
1078
1079 /**********************************************************************
1080  *  QueryServiceStatus
1081  *
1082  * @implemented
1083  */
1084 BOOL STDCALL
1085 QueryServiceStatus(SC_HANDLE hService,
1086                    LPSERVICE_STATUS lpServiceStatus)
1087 {
1088     DWORD dwError;
1089
1090     DPRINT("QueryServiceStatus(%p, %p)\n",
1091            hService, lpServiceStatus);
1092
1093     HandleBind();
1094
1095     /* Call to services.exe using RPC */
1096     dwError = ScmrQueryServiceStatus(BindingHandle,
1097                                      (unsigned int)hService,
1098                                      lpServiceStatus);
1099     if (dwError != ERROR_SUCCESS)
1100     {
1101         DPRINT1("ScmrQueryServiceStatus() failed (Error %lu)\n", dwError);
1102         SetLastError(dwError);
1103         return FALSE;
1104     }
1105
1106     return TRUE;
1107 }
1108
1109
1110 /**********************************************************************
1111  *  QueryServiceStatusEx
1112  *
1113  * @unimplemented
1114  */
1115 BOOL
1116 STDCALL
1117 QueryServiceStatusEx(SC_HANDLE  hService,
1118   SC_STATUS_TYPE  InfoLevel,
1119   LPBYTE  lpBuffer,
1120   DWORD  cbBufSize,
1121   LPDWORD  pcbBytesNeeded)
1122 {
1123     DPRINT1("QueryServiceStatusEx is unimplemented\n");
1124     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1125     return FALSE;
1126 }
1127
1128
1129 /**********************************************************************
1130  *  StartServiceA
1131  *
1132  * @unimplemented
1133  */
1134 BOOL
1135 STDCALL
1136 StartServiceA(
1137     SC_HANDLE   hService,
1138     DWORD       dwNumServiceArgs,
1139     LPCSTR      *lpServiceArgVectors)
1140 {
1141     DPRINT1("StartServiceA is unimplemented\n");
1142     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1143     return FALSE;
1144 }
1145
1146
1147 /**********************************************************************
1148  *  StartServiceW
1149  *
1150  * @unimplemented
1151  */
1152 BOOL
1153 STDCALL
1154 StartServiceW(
1155     SC_HANDLE   hService,
1156     DWORD       dwNumServiceArgs,
1157     LPCWSTR     *lpServiceArgVectors)
1158 {
1159     DPRINT1("StartServiceW is unimplemented, but returns success...\n");
1160     //SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1161     //return FALSE;
1162     return TRUE;
1163 }
1164
1165
1166 /**********************************************************************
1167  *  UnlockServiceDatabase
1168  *
1169  * @implemented
1170  */
1171 BOOL STDCALL
1172 UnlockServiceDatabase(SC_LOCK ScLock)
1173 {
1174     DWORD dwError;
1175
1176     DPRINT("UnlockServiceDatabase(%x)\n", ScLock);
1177
1178     HandleBind();
1179
1180     /* Call to services.exe using RPC */
1181     dwError = ScmrUnlockServiceDatabase(BindingHandle,
1182                                         (unsigned int)ScLock);
1183     if (dwError != ERROR_SUCCESS)
1184     {
1185         DPRINT1("ScmrUnlockServiceDatabase() failed (Error %lu)\n", dwError);
1186         SetLastError(dwError);
1187         return FALSE;
1188     }
1189
1190     return TRUE;
1191 }
1192
1193
1194 /**********************************************************************
1195  *  NotifyBootConfigStatus
1196  *
1197  * @implemented
1198  */
1199 BOOL STDCALL
1200 NotifyBootConfigStatus(BOOL BootAcceptable)
1201 {
1202     DWORD dwError;
1203
1204     DPRINT1("NotifyBootConfigStatus()\n");
1205
1206     HandleBind();
1207
1208     /* Call to services.exe using RPC */
1209     dwError = ScmrNotifyBootConfigStatus(BindingHandle,
1210                                          BootAcceptable);
1211     if (dwError != ERROR_SUCCESS)
1212     {
1213         DPRINT1("NotifyBootConfigStatus() failed (Error %lu)\n", dwError);
1214         SetLastError(dwError);
1215         return FALSE;
1216     }
1217
1218     return TRUE;
1219 }
1220
1221
1222 void __RPC_FAR * __RPC_USER midl_user_allocate(size_t len)
1223 {
1224     return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
1225 }
1226
1227
1228 void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
1229 {
1230     HeapFree(GetProcessHeap(), 0, ptr);
1231 }
1232
1233 /* EOF */