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     DPRINT1("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  * @unimplemented
 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     DPRINT1("CreateServiceA is unimplemented, but returning INVALID_HANDLE_VALUE instead of NULL\n");
 281     return INVALID_HANDLE_VALUE;
 282 }
 283
 284
 285 /**********************************************************************
 286  *  CreateServiceW
 287  *
 288  * @implemented
 289  */
 290 SC_HANDLE STDCALL
 291 CreateServiceW(SC_HANDLE hSCManager,
 292                LPCWSTR lpServiceName,
 293                LPCWSTR lpDisplayName,
 294                DWORD dwDesiredAccess,
 295                DWORD dwServiceType,
 296                DWORD dwStartType,
 297                DWORD dwErrorControl,
 298                LPCWSTR lpBinaryPathName,
 299                LPCWSTR lpLoadOrderGroup,
 300                LPDWORD lpdwTagId,
 301                LPCWSTR lpDependencies,
 302                LPCWSTR lpServiceStartName,
 303                LPCWSTR lpPassword)
 304 {
 305     SC_HANDLE hService = NULL;
 306     DWORD dwError;
 307     DWORD dwDependenciesLength = 0;
 308     DWORD dwLength;
 309     LPWSTR lpStr;
 310
 311     DPRINT1("CreateServiceW() called\n");
 312
 313     /* Calculate the Dependencies length*/
 314     if (lpDependencies != NULL)
 315     {
 316         lpStr = (LPWSTR)lpDependencies;
 317         while (*lpStr)
 318         {
 319             dwLength = wcslen(lpStr) + 1;
 320             dwDependenciesLength += dwLength;
 321             lpStr = lpStr + dwLength;
 322         }
 323         dwDependenciesLength++;
 324     }
 325
 326     /* FIXME: Encrypt the password */
 327
 328     HandleBind();
 329
 330     /* Call to services.exe using RPC */
 331     dwError = ScmrCreateServiceW(BindingHandle,
 332                                  (unsigned int)hSCManager,
 333                                  (LPWSTR)lpServiceName,
 334                                  (LPWSTR)lpDisplayName,
 335                                  dwDesiredAccess,
 336                                  dwServiceType,
 337                                  dwStartType,
 338                                  dwErrorControl,
 339                                  (LPWSTR)lpBinaryPathName,
 340                                  (LPWSTR)lpLoadOrderGroup,
 341                                  lpdwTagId,
 342                                  (LPWSTR)lpDependencies,
 343                                  dwDependenciesLength,
 344                                  (LPWSTR)lpServiceStartName,
 345                                  NULL,              /* FIXME: lpPassword */
 346                                  0,                 /* FIXME: dwPasswordLength */
 347                                  (unsigned int *)&hService);
 348     if (dwError != ERROR_SUCCESS)
 349     {
 350         DPRINT1("ScmrCreateServiceW() failed (Error %lu)\n", dwError);
 351         SetLastError(dwError);
 352         return INVALID_HANDLE_VALUE;
 353     }
 354
 355     return hService;
 356 }
 357
 358
 359 /**********************************************************************
 360  *  DeleteService
 361  *
 362  * @implemented
 363  */
 364 BOOL STDCALL
 365 DeleteService(SC_HANDLE hService)
 366 {
 367   DWORD dwError;
 368
 369   DPRINT("DeleteService(%x)\n", hService);
 370
 371   HandleBind();
 372
 373   /* Call to services.exe using RPC */
 374   dwError = ScmrDeleteService(BindingHandle,
 375                               (unsigned int)hService);
 376   if (dwError != ERROR_SUCCESS)
 377   {
 378     DPRINT1("ScmrDeleteService() failed (Error %lu)\n", dwError);
 379     SetLastError(dwError);
 380     return FALSE;
 381   }
 382
 383   return TRUE;
 384 }
 385
 386
 387 /**********************************************************************
 388  *  EnumDependentServicesA
 389  *
 390  * @unimplemented
 391  */
 392 BOOL
 393 STDCALL
 394 EnumDependentServicesA(
 395     SC_HANDLE       hService,
 396     DWORD           dwServiceState,
 397     LPENUM_SERVICE_STATUSA  lpServices,
 398     DWORD           cbBufSize,
 399     LPDWORD         pcbBytesNeeded,
 400     LPDWORD         lpServicesReturned)
 401 {
 402     DPRINT1("EnumDependentServicesA is unimplemented\n");
 403     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 404     return FALSE;
 405 }
 406
 407
 408 /**********************************************************************
 409  *  EnumDependentServicesW
 410  *
 411  * @unimplemented
 412  */
 413 BOOL
 414 STDCALL
 415 EnumDependentServicesW(
 416     SC_HANDLE       hService,
 417     DWORD           dwServiceState,
 418     LPENUM_SERVICE_STATUSW  lpServices,
 419     DWORD           cbBufSize,
 420     LPDWORD         pcbBytesNeeded,
 421     LPDWORD         lpServicesReturned)
 422 {
 423     DPRINT1("EnumDependentServicesW is unimplemented\n");
 424     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 425     return FALSE;
 426 }
 427
 428
 429 /**********************************************************************
 430  *  EnumServiceGroupW
 431  *
 432  * @unimplemented
 433  */
 434 BOOL
 435 STDCALL
 436 EnumServiceGroupW (
 437     DWORD   Unknown0,
 438     DWORD   Unknown1,
 439     DWORD   Unknown2,
 440     DWORD   Unknown3,
 441     DWORD   Unknown4,
 442     DWORD   Unknown5,
 443     DWORD   Unknown6,
 444     DWORD   Unknown7,
 445     DWORD   Unknown8)
 446 {
 447     DPRINT1("EnumServiceGroupW is unimplemented\n");
 448     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 449     return FALSE;
 450 }
 451
 452
 453 /**********************************************************************
 454  *  EnumServicesStatusA
 455  *
 456  * @unimplemented
 457  */
 458 BOOL
 459 STDCALL
 460 EnumServicesStatusA (
 461     SC_HANDLE               hSCManager,
 462     DWORD                   dwServiceType,
 463     DWORD                   dwServiceState,
 464     LPENUM_SERVICE_STATUSA  lpServices,
 465     DWORD                   cbBufSize,
 466     LPDWORD                 pcbBytesNeeded,
 467     LPDWORD                 lpServicesReturned,
 468     LPDWORD                 lpResumeHandle)
 469 {
 470     DPRINT1("EnumServicesStatusA is unimplemented\n");
 471     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 472     return FALSE;
 473 }
 474
 475
 476 /**********************************************************************
 477  *  EnumServicesStatusExA
 478  *
 479  * @unimplemented
 480  */
 481 BOOL
 482 STDCALL
 483 EnumServicesStatusExA(SC_HANDLE  hSCManager,
 484   SC_ENUM_TYPE  InfoLevel,
 485   DWORD  dwServiceType,
 486   DWORD  dwServiceState,
 487   LPBYTE  lpServices,
 488   DWORD  cbBufSize,
 489   LPDWORD  pcbBytesNeeded,
 490   LPDWORD  lpServicesReturned,
 491   LPDWORD  lpResumeHandle,
 492   LPCSTR  pszGroupName)
 493 {
 494     DPRINT1("EnumServicesStatusExA is unimplemented\n");
 495     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 496     return FALSE;
 497 }
 498
 499
 500 /**********************************************************************
 501  *  EnumServicesStatusExW
 502  *
 503  * @unimplemented
 504  */
 505 BOOL
 506 STDCALL
 507 EnumServicesStatusExW(SC_HANDLE  hSCManager,
 508   SC_ENUM_TYPE  InfoLevel,
 509   DWORD  dwServiceType,
 510   DWORD  dwServiceState,
 511   LPBYTE  lpServices,
 512   DWORD  cbBufSize,
 513   LPDWORD  pcbBytesNeeded,
 514   LPDWORD  lpServicesReturned,
 515   LPDWORD  lpResumeHandle,
 516   LPCWSTR  pszGroupName)
 517 {
 518     DPRINT1("EnumServicesStatusExW is unimplemented\n");
 519     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 520     return FALSE;
 521 }
 522
 523
 524 /**********************************************************************
 525  *  EnumServicesStatusW
 526  *
 527  * @unimplemented
 528  */
 529 BOOL
 530 STDCALL
 531 EnumServicesStatusW(
 532     SC_HANDLE               hSCManager,
 533     DWORD                   dwServiceType,
 534     DWORD                   dwServiceState,
 535     LPENUM_SERVICE_STATUSW  lpServices,
 536     DWORD                   cbBufSize,
 537     LPDWORD                 pcbBytesNeeded,
 538     LPDWORD                 lpServicesReturned,
 539     LPDWORD                 lpResumeHandle)
 540 {
 541     DPRINT1("EnumServicesStatusW is unimplemented\n");
 542     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 543     return FALSE;
 544 }
 545
 546
 547 /**********************************************************************
 548  *  GetServiceDisplayNameA
 549  *
 550  * @unimplemented
 551  */
 552 BOOL
 553 STDCALL
 554 GetServiceDisplayNameA(
 555     SC_HANDLE   hSCManager,
 556     LPCSTR      lpServiceName,
 557     LPSTR       lpDisplayName,
 558     LPDWORD     lpcchBuffer)
 559 {
 560     DPRINT1("GetServiceDisplayNameA is unimplemented\n");
 561     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 562     return FALSE;
 563 }
 564
 565
 566 /**********************************************************************
 567  *  GetServiceDisplayNameW
 568  *
 569  * @implemented
 570  */
 571 BOOL STDCALL
 572 GetServiceDisplayNameW(SC_HANDLE hSCManager,
 573                        LPCWSTR lpServiceName,
 574                        LPWSTR lpDisplayName,
 575                        LPDWORD lpcchBuffer)
 576 {
 577     DWORD dwError;
 578
 579     DPRINT("GetServiceDisplayNameW() called\n");
 580
 581     HandleBind();
 582
 583     dwError = ScmrGetServiceDisplayNameW(BindingHandle,
 584                                          (unsigned int)hSCManager,
 585                                          (LPWSTR)lpServiceName,
 586                                          lpDisplayName,
 587                                          lpcchBuffer);
 588     if (dwError != ERROR_SUCCESS)
 589     {
 590         DPRINT1("ScmrGetServiceDisplayNameW() failed (Error %lu)\n", dwError);
 591         SetLastError(dwError);
 592         return FALSE;
 593     }
 594
 595     return TRUE;
 596 }
 597
 598
 599 /**********************************************************************
 600  *  GetServiceKeyNameA
 601  *
 602  * @unimplemented
 603  */
 604 BOOL
 605 STDCALL
 606 GetServiceKeyNameA(
 607     SC_HANDLE   hSCManager,
 608     LPCSTR      lpDisplayName,
 609     LPSTR       lpServiceName,
 610     LPDWORD     lpcchBuffer)
 611 {
 612     DPRINT1("GetServiceKeyNameA is unimplemented\n");
 613     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 614     return FALSE;
 615 }
 616
 617
 618 /**********************************************************************
 619  *  GetServiceKeyNameW
 620  *
 621  * @implemented
 622  */
 623 BOOL STDCALL
 624 GetServiceKeyNameW(SC_HANDLE hSCManager,
 625                    LPCWSTR lpDisplayName,
 626                    LPWSTR lpServiceName,
 627                    LPDWORD lpcchBuffer)
 628 {
 629     DWORD dwError;
 630
 631     DPRINT("GetServiceKeyNameW() called\n");
 632
 633     HandleBind();
 634
 635     dwError = ScmrGetServiceKeyNameW(BindingHandle,
 636                                      (unsigned int)hSCManager,
 637                                      (LPWSTR)lpDisplayName,
 638                                      lpServiceName,
 639                                      lpcchBuffer);
 640     if (dwError != ERROR_SUCCESS)
 641     {
 642         DPRINT1("ScmrGetServiceKeyNameW() failed (Error %lu)\n", dwError);
 643         SetLastError(dwError);
 644         return FALSE;
 645     }
 646
 647     return TRUE;
 648 }
 649
 650
 651 /**********************************************************************
 652  *  LockServiceDatabase
 653  *
 654  * @implemented
 655  */
 656 SC_LOCK STDCALL
 657 LockServiceDatabase(SC_HANDLE hSCManager)
 658 {
 659   SC_LOCK hLock;
 660   DWORD dwError;
 661
 662   DPRINT("LockServiceDatabase(%x)\n", hSCManager);
 663
 664   HandleBind();
 665
 666   /* Call to services.exe using RPC */
 667   dwError = ScmrLockServiceDatabase(BindingHandle,
 668                                     (unsigned int)hSCManager,
 669                                     (unsigned int *)&hLock);
 670   if (dwError != ERROR_SUCCESS)
 671   {
 672     DPRINT1("ScmrLockServiceDatabase() failed (Error %lu)\n", dwError);
 673     SetLastError(dwError);
 674     return NULL;
 675   }
 676
 677   DPRINT("hLock = %p\n", hLock);
 678
 679   return hLock;
 680 }
 681
 682
 683 static VOID
 684 WaitForSCManager(VOID)
 685 {
 686   HANDLE hEvent;
 687
 688   DPRINT("WaitForSCManager() called\n");
 689
 690   /* Try to open the existing event */
 691   hEvent = OpenEventW(SYNCHRONIZE,
 692                       FALSE,
 693                       L"SvcctrlStartEvent_A3725DX");
 694   if (hEvent == NULL)
 695   {
 696     if (GetLastError() != ERROR_FILE_NOT_FOUND)
 697       return;
 698
 699     /* Try to create a new event */
 700     hEvent = CreateEventW(NULL,
 701                           TRUE,
 702                           FALSE,
 703                           L"SvcctrlStartEvent_A3725DX");
 704     if (hEvent == NULL)
 705     {
 706       /* Try to open the existing event again */
 707       hEvent = OpenEventW(SYNCHRONIZE,
 708                           FALSE,
 709                           L"SvcctrlStartEvent_A3725DX");
 710       if (hEvent == NULL)
 711         return;
 712     }
 713   }
 714
 715   /* Wait for 3 minutes */
 716   WaitForSingleObject(hEvent, 180000);
 717   CloseHandle(hEvent);
 718
 719   DPRINT("ScmWaitForSCManager() done\n");
 720 }
 721
 722
 723 /**********************************************************************
 724  *  OpenSCManagerA
 725  *
 726  * @implemented
 727  */
 728 SC_HANDLE STDCALL
 729 OpenSCManagerA(LPCSTR lpMachineName,
 730                LPCSTR lpDatabaseName,
 731                DWORD dwDesiredAccess)
 732 {
 733   SC_HANDLE hScm = NULL;
 734   DWORD dwError;
 735
 736   DPRINT("OpenSCManagerA(%s, %s, %lx)\n",
 737          lpMachineName, lpDatabaseName, dwDesiredAccess);
 738
 739   WaitForSCManager();
 740
 741   HandleBind();
 742
 743   /* Call to services.exe using RPC */
 744   dwError = ScmrOpenSCManagerA(BindingHandle,
 745                                (LPSTR)lpMachineName,
 746                                (LPSTR)lpDatabaseName,
 747                                dwDesiredAccess,
 748                                (unsigned int*)&hScm);
 749   if (dwError != ERROR_SUCCESS)
 750   {
 751     DPRINT1("ScmrOpenSCManagerA() failed (Error %lu)\n", dwError);
 752     SetLastError(dwError);
 753     return NULL;
 754   }
 755
 756   DPRINT("hScm = %p\n", hScm);
 757
 758   return hScm;
 759 }
 760
 761
 762 /**********************************************************************
 763  *  OpenSCManagerW
 764  *
 765  * @implemented
 766  */
 767 SC_HANDLE STDCALL
 768 OpenSCManagerW(LPCWSTR lpMachineName,
 769                LPCWSTR lpDatabaseName,
 770                DWORD dwDesiredAccess)
 771 {
 772   SC_HANDLE hScm = NULL;
 773   DWORD dwError;
 774
 775   DPRINT("OpenSCManagerW(%S, %S, %lx)\n",
 776          lpMachineName, lpDatabaseName, dwDesiredAccess);
 777
 778   WaitForSCManager();
 779
 780   HandleBind();
 781
 782   /* Call to services.exe using RPC */
 783   dwError = ScmrOpenSCManagerW(BindingHandle,
 784                                (LPWSTR)lpMachineName,
 785                                (LPWSTR)lpDatabaseName,
 786                                dwDesiredAccess,
 787                                (unsigned int*)&hScm);
 788   if (dwError != ERROR_SUCCESS)
 789   {
 790     DPRINT1("ScmrOpenSCManagerW() failed (Error %lu)\n", dwError);
 791     SetLastError(dwError);
 792     return NULL;
 793   }
 794
 795   DPRINT("hScm = %p\n", hScm);
 796
 797   return hScm;
 798 }
 799
 800
 801 /**********************************************************************
 802  *  OpenServiceA
 803  *
 804  * @implemented
 805  */
 806 SC_HANDLE STDCALL
 807 OpenServiceA(SC_HANDLE hSCManager,
 808              LPCSTR lpServiceName,
 809              DWORD dwDesiredAccess)
 810 {
 811   SC_HANDLE hService = NULL;
 812   DWORD dwError;
 813
 814   DPRINT("OpenServiceA(%p, %s, %lx)\n",
 815          hSCManager, lpServiceName, dwDesiredAccess);
 816
 817   HandleBind();
 818
 819   /* Call to services.exe using RPC */
 820   dwError = ScmrOpenServiceA(BindingHandle,
 821                              (unsigned int)hSCManager,
 822                              (LPSTR)lpServiceName,
 823                              dwDesiredAccess,
 824                              (unsigned int*)&hService);
 825   if (dwError != ERROR_SUCCESS)
 826   {
 827     DPRINT1("ScmrOpenServiceA() failed (Error %lu)\n", dwError);
 828     SetLastError(dwError);
 829     return NULL;
 830   }
 831
 832   DPRINT("hService = %p\n", hService);
 833
 834   return hService;
 835 }
 836
 837
 838 /**********************************************************************
 839  *  OpenServiceW
 840  *
 841  * @implemented
 842  */
 843 SC_HANDLE STDCALL
 844 OpenServiceW(SC_HANDLE hSCManager,
 845              LPCWSTR lpServiceName,
 846              DWORD dwDesiredAccess)
 847 {
 848   SC_HANDLE hService = NULL;
 849   DWORD dwError;
 850
 851   DPRINT("OpenServiceW(%p, %S, %lx)\n",
 852          hSCManager, lpServiceName, dwDesiredAccess);
 853
 854   HandleBind();
 855
 856   /* Call to services.exe using RPC */
 857   dwError = ScmrOpenServiceW(BindingHandle,
 858                              (unsigned int)hSCManager,
 859                              (LPWSTR)lpServiceName,
 860                              dwDesiredAccess,
 861                              (unsigned int*)&hService);
 862   if (dwError != ERROR_SUCCESS)
 863   {
 864     DPRINT1("ScmrOpenServiceW() failed (Error %lu)\n", dwError);
 865     SetLastError(dwError);
 866     return NULL;
 867   }
 868
 869   DPRINT("hService = %p\n", hService);
 870
 871   return hService;
 872 }
 873
 874
 875 /**********************************************************************
 876  *  QueryServiceConfigA
 877  *
 878  * @unimplemented
 879  */
 880 BOOL
 881 STDCALL
 882 QueryServiceConfigA(
 883     SC_HANDLE       hService,
 884     LPQUERY_SERVICE_CONFIGA lpServiceConfig,
 885     DWORD           cbBufSize,
 886     LPDWORD         pcbBytesNeeded)
 887 {
 888     DPRINT1("QueryServiceConfigA is unimplemented\n");
 889     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 890     return FALSE;
 891 }
 892
 893
 894 /**********************************************************************
 895  *  QueryServiceConfigW
 896  *
 897  * @unimplemented
 898  */
 899 BOOL
 900 STDCALL
 901 QueryServiceConfigW(
 902     SC_HANDLE       hService,
 903     LPQUERY_SERVICE_CONFIGW lpServiceConfig,
 904     DWORD                   cbBufSize,
 905     LPDWORD                 pcbBytesNeeded)
 906 {
 907     DPRINT1("QueryServiceConfigW is unimplemented\n");
 908     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 909     return FALSE;
 910 }
 911
 912
 913 /**********************************************************************
 914  *  QueryServiceLockStatusA
 915  *
 916  * @unimplemented
 917  */
 918 BOOL
 919 STDCALL
 920 QueryServiceLockStatusA(
 921     SC_HANDLE           hSCManager,
 922     LPQUERY_SERVICE_LOCK_STATUSA    lpLockStatus,
 923     DWORD               cbBufSize,
 924     LPDWORD             pcbBytesNeeded)
 925 {
 926     DPRINT1("QueryServiceLockStatusA is unimplemented\n");
 927     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 928     return FALSE;
 929 }
 930
 931
 932 /**********************************************************************
 933  *  QueryServiceLockStatusW
 934  *
 935  * @unimplemented
 936  */
 937 BOOL
 938 STDCALL
 939 QueryServiceLockStatusW(
 940     SC_HANDLE           hSCManager,
 941     LPQUERY_SERVICE_LOCK_STATUSW    lpLockStatus,
 942     DWORD               cbBufSize,
 943     LPDWORD             pcbBytesNeeded)
 944 {
 945     DPRINT1("QueryServiceLockStatusW is unimplemented\n");
 946     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 947     return FALSE;
 948 }
 949
 950
 951 /**********************************************************************
 952  *  QueryServiceObjectSecurity
 953  *
 954  * @unimplemented
 955  */
 956 BOOL
 957 STDCALL
 958 QueryServiceObjectSecurity(
 959     SC_HANDLE       hService,
 960     SECURITY_INFORMATION    dwSecurityInformation,
 961     PSECURITY_DESCRIPTOR    lpSecurityDescriptor,
 962     DWORD           cbBufSize,
 963     LPDWORD         pcbBytesNeeded)
 964 {
 965     DPRINT1("QueryServiceObjectSecurity is unimplemented\n");
 966     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 967     return FALSE;
 968 }
 969
 970
 971 /**********************************************************************
 972  *  QueryServiceStatus
 973  *
 974  * @implemented
 975  */
 976 BOOL STDCALL
 977 QueryServiceStatus(SC_HANDLE hService,
 978                    LPSERVICE_STATUS lpServiceStatus)
 979 {
 980   DWORD dwError;
 981
 982   DPRINT("QueryServiceStatus(%p, %p)\n",
 983          hService, lpServiceStatus);
 984
 985   HandleBind();
 986
 987   /* Call to services.exe using RPC */
 988   dwError = ScmrQueryServiceStatus(BindingHandle,
 989                                    (unsigned int)hService,
 990                                    lpServiceStatus);
 991   if (dwError != ERROR_SUCCESS)
 992   {
 993     DPRINT1("ScmrQueryServiceStatus() failed (Error %lu)\n", dwError);
 994     SetLastError(dwError);
 995     return FALSE;
 996   }
 997
 998   return TRUE;
 999 }
1000
1001
1002 /**********************************************************************
1003  *  QueryServiceStatusEx
1004  *
1005  * @unimplemented
1006  */
1007 BOOL
1008 STDCALL
1009 QueryServiceStatusEx(SC_HANDLE  hService,
1010   SC_STATUS_TYPE  InfoLevel,
1011   LPBYTE  lpBuffer,
1012   DWORD  cbBufSize,
1013   LPDWORD  pcbBytesNeeded)
1014 {
1015     DPRINT1("QueryServiceStatusEx is unimplemented\n");
1016     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1017     return FALSE;
1018 }
1019
1020
1021 /**********************************************************************
1022  *  StartServiceA
1023  *
1024  * @unimplemented
1025  */
1026 BOOL
1027 STDCALL
1028 StartServiceA(
1029     SC_HANDLE   hService,
1030     DWORD       dwNumServiceArgs,
1031     LPCSTR      *lpServiceArgVectors)
1032 {
1033     DPRINT1("StartServiceA is unimplemented\n");
1034     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1035     return FALSE;
1036 }
1037
1038
1039 /**********************************************************************
1040  *  StartServiceW
1041  *
1042  * @unimplemented
1043  */
1044 BOOL
1045 STDCALL
1046 StartServiceW(
1047     SC_HANDLE   hService,
1048     DWORD       dwNumServiceArgs,
1049     LPCWSTR     *lpServiceArgVectors)
1050 {
1051     DPRINT1("StartServiceW is unimplemented\n");
1052     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1053     return FALSE;
1054 }
1055
1056
1057 /**********************************************************************
1058  *  UnlockServiceDatabase
1059  *
1060  * @implemented
1061  */
1062 BOOL STDCALL
1063 UnlockServiceDatabase(SC_LOCK ScLock)
1064 {
1065   DWORD dwError;
1066
1067   DPRINT("UnlockServiceDatabase(%x)\n", ScLock);
1068
1069   HandleBind();
1070
1071   /* Call to services.exe using RPC */
1072   dwError = ScmrUnlockServiceDatabase(BindingHandle,
1073                                       (unsigned int)ScLock);
1074   if (dwError != ERROR_SUCCESS)
1075   {
1076     DPRINT1("ScmrUnlockServiceDatabase() failed (Error %lu)\n", dwError);
1077     SetLastError(dwError);
1078     return FALSE;
1079   }
1080
1081   return TRUE;
1082 }
1083
1084
1085 /**********************************************************************
1086  *  NotifyBootConfigStatus
1087  *
1088  * @implemented
1089  */
1090 BOOL STDCALL
1091 NotifyBootConfigStatus(BOOL BootAcceptable)
1092 {
1093     DWORD dwError;
1094
1095     DPRINT1("NotifyBootConfigStatus()\n");
1096
1097     HandleBind();
1098
1099     /* Call to services.exe using RPC */
1100     dwError = ScmrNotifyBootConfigStatus(BindingHandle,
1101                                          BootAcceptable);
1102     if (dwError != ERROR_SUCCESS)
1103     {
1104         DPRINT1("NotifyBootConfigStatus() failed (Error %lu)\n", dwError);
1105         SetLastError(dwError);
1106         return FALSE;
1107     }
1108
1109     return TRUE;
1110 }
1111
1112
1113 void __RPC_FAR * __RPC_USER midl_user_allocate(size_t len)
1114 {
1115   return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
1116 }
1117
1118
1119 void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
1120 {
1121   HeapFree(GetProcessHeap(), 0, ptr);
1122 }
1123
1124 /* EOF */