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  * @unimplemented
 110  */
 111 BOOL
 112 STDCALL
 113 ChangeServiceConfigW(
 114     SC_HANDLE   hService,
 115     DWORD       dwServiceType,
 116     DWORD       dwStartType,
 117     DWORD       dwErrorControl,
 118     LPCWSTR     lpBinaryPathName,
 119     LPCWSTR     lpLoadOrderGroup,
 120     LPDWORD     lpdwTagId,
 121     LPCWSTR     lpDependencies,
 122     LPCWSTR     lpServiceStartName,
 123     LPCWSTR     lpPassword,
 124     LPCWSTR     lpDisplayName)
 125 {
 126     DPRINT1("ChangeServiceConfigW is unimplemented\n");
 127     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 128     return FALSE;
 129 }
 130
 131
 132 /**********************************************************************
 133  *  CloseServiceHandle
 134  *
 135  * @implemented
 136  */
 137 BOOL STDCALL
 138 CloseServiceHandle(SC_HANDLE hSCObject)
 139 {
 140   DWORD dwError;
 141
 142   DPRINT("CloseServiceHandle() called\n");
 143
 144   HandleBind();
 145
 146   /* Call to services.exe using RPC */
 147   dwError = ScmrCloseServiceHandle(BindingHandle,
 148                                    (unsigned int)hSCObject);
 149   if (dwError)
 150   {
 151     DPRINT1("ScmrCloseServiceHandle() failed (Error %lu)\n", dwError);
 152     SetLastError(dwError);
 153     return FALSE;
 154   }
 155
 156   DPRINT("CloseServiceHandle() done\n");
 157
 158   return TRUE;
 159 }
 160
 161
 162 /**********************************************************************
 163  *  ControlService
 164  *
 165  * @unimplemented
 166  */
 167 BOOL STDCALL
 168 ControlService(SC_HANDLE        hService,
 169                DWORD            dwControl,
 170                LPSERVICE_STATUS lpServiceStatus)
 171 {
 172   DWORD dwError;
 173
 174   DPRINT("ControlService(%x, %x, %p)\n",
 175          hService, dwControl, lpServiceStatus);
 176
 177   HandleBind();
 178
 179   /* Call to services.exe using RPC */
 180   dwError = ScmrControlService(BindingHandle,
 181                                (unsigned int)hService,
 182                                dwControl,
 183                                lpServiceStatus);
 184   if (dwError != ERROR_SUCCESS)
 185   {
 186     DPRINT1("ScmrControlService() failed (Error %lu)\n", dwError);
 187     SetLastError(dwError);
 188     return FALSE;
 189   }
 190
 191   DPRINT("ControlService() done\n");
 192
 193   return TRUE;
 194 }
 195
 196
 197 /**********************************************************************
 198  *  ControlServiceEx
 199  *
 200  * @unimplemented
 201  */
 202 BOOL STDCALL
 203 ControlServiceEx(IN SC_HANDLE hService,
 204                  IN DWORD dwControl,
 205                  IN DWORD dwInfoLevel,
 206                  IN OUT PVOID pControlParams)
 207 {
 208     DPRINT1("ControlServiceEx(0x%p, 0x%x, 0x%x, 0x%p) UNIMPLEMENTED!\n",
 209             hService, dwControl, dwInfoLevel, pControlParams);
 210     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 211     return FALSE;
 212 }
 213
 214
 215
 216 /**********************************************************************
 217  *  CreateServiceA
 218  *
 219  * @unimplemented
 220  */
 221 SC_HANDLE
 222 STDCALL
 223 CreateServiceA(
 224     SC_HANDLE   hSCManager,
 225     LPCSTR      lpServiceName,
 226     LPCSTR      lpDisplayName,
 227     DWORD       dwDesiredAccess,
 228     DWORD       dwServiceType,
 229     DWORD       dwStartType,
 230     DWORD       dwErrorControl,
 231     LPCSTR      lpBinaryPathName,
 232     LPCSTR      lpLoadOrderGroup,
 233     LPDWORD     lpdwTagId,
 234     LPCSTR      lpDependencies,
 235     LPCSTR      lpServiceStartName,
 236     LPCSTR      lpPassword)
 237 {
 238     DPRINT1("CreateServiceA is unimplemented, but returning INVALID_HANDLE_VALUE instead of NULL\n");
 239     return INVALID_HANDLE_VALUE;
 240 }
 241
 242
 243 /**********************************************************************
 244  *  CreateServiceW
 245  *
 246  * @unimplemented
 247  */
 248 SC_HANDLE STDCALL
 249 CreateServiceW(SC_HANDLE hSCManager,
 250                LPCWSTR lpServiceName,
 251                LPCWSTR lpDisplayName,
 252                DWORD dwDesiredAccess,
 253                DWORD dwServiceType,
 254                DWORD dwStartType,
 255                DWORD dwErrorControl,
 256                LPCWSTR lpBinaryPathName,
 257                LPCWSTR lpLoadOrderGroup,
 258                LPDWORD lpdwTagId,
 259                LPCWSTR lpDependencies,
 260                LPCWSTR lpServiceStartName,
 261                LPCWSTR lpPassword)
 262 {
 263     SC_HANDLE hService = NULL;
 264     DWORD dwError;
 265     HKEY hEnumKey, hKey;
 266
 267     DPRINT1("CreateServiceW() called\n");
 268
 269     HandleBind();
 270
 271     /* Call to services.exe using RPC */
 272 #if 0
 273     dwError = ScmrCreateServiceW(BindingHandle,
 274                                  (unsigned int)hSCManager,
 275                                  (LPWSTR)lpServiceName,
 276                                  (LPWSTR)lpDisplayName,
 277                                  dwDesiredAccess,
 278                                  dwServiceType,
 279                                  dwStartType,
 280                                  dwErrorControl,
 281                                  (LPWSTR)lpBinaryPathName,
 282                                  (LPWSTR)lpLoadOrderGroup,
 283                                  lpdwTagId,
 284                                  NULL,              /* FIXME: lpDependencies */
 285                                  0,                 /* FIXME: dwDependenciesLength */
 286                                  (LPWSTR)lpServiceStartName,
 287                                  NULL,              /* FIXME: lpPassword */
 288                                  0,                 /* FIXME: dwPasswordLength */
 289                                  (unsigned int *)&hService);
 290 #else
 291     RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Services", 0, KEY_ENUMERATE_SUB_KEYS, &hEnumKey);
 292     RegCreateKeyExW(hEnumKey, lpServiceName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, NULL, &hKey, NULL);
 293     RegCloseKey(hEnumKey);
 294     if (lpLoadOrderGroup)
 295       RegSetValueExW(hKey, L"Group", 0, REG_SZ, (const BYTE*)lpLoadOrderGroup, (wcslen(lpLoadOrderGroup) + 1) * sizeof(WCHAR));
 296     RegSetValueExW(hKey, L"ImagePath", 0, REG_EXPAND_SZ, (const BYTE*)lpBinaryPathName, (wcslen(lpBinaryPathName) + 1) * sizeof(WCHAR));
 297     RegSetValueExW(hKey, L"ErrorControl", 0, REG_DWORD, (const BYTE*)&dwErrorControl, sizeof(dwErrorControl));
 298     RegSetValueExW(hKey, L"Start", 0, REG_DWORD, (const BYTE*)&dwStartType, sizeof(dwStartType));
 299     RegSetValueExW(hKey, L"Type", 0, REG_DWORD, (const BYTE*)&dwStartType, sizeof(dwStartType));
 300     RegCloseKey(hKey);
 301     hService = INVALID_HANDLE_VALUE; dwError = ERROR_SUCCESS;
 302 #endif
 303     if (dwError != ERROR_SUCCESS)
 304     {
 305         DPRINT1("ScmrCreateServiceW() failed (Error %lu)\n", dwError);
 306         SetLastError(dwError);
 307         return INVALID_HANDLE_VALUE;
 308     }
 309
 310     return hService;
 311 }
 312
 313
 314 /**********************************************************************
 315  *  DeleteService
 316  *
 317  * @implemented
 318  */
 319 BOOL STDCALL
 320 DeleteService(SC_HANDLE hService)
 321 {
 322   DWORD dwError;
 323
 324   DPRINT("DeleteService(%x)\n", hService);
 325
 326   HandleBind();
 327
 328   /* Call to services.exe using RPC */
 329   dwError = ScmrDeleteService(BindingHandle,
 330                               (unsigned int)hService);
 331   if (dwError != ERROR_SUCCESS)
 332   {
 333     DPRINT1("ScmrDeleteService() failed (Error %lu)\n", dwError);
 334     SetLastError(dwError);
 335     return FALSE;
 336   }
 337
 338   return TRUE;
 339 }
 340
 341
 342 /**********************************************************************
 343  *  EnumDependentServicesA
 344  *
 345  * @unimplemented
 346  */
 347 BOOL
 348 STDCALL
 349 EnumDependentServicesA(
 350     SC_HANDLE       hService,
 351     DWORD           dwServiceState,
 352     LPENUM_SERVICE_STATUSA  lpServices,
 353     DWORD           cbBufSize,
 354     LPDWORD         pcbBytesNeeded,
 355     LPDWORD         lpServicesReturned)
 356 {
 357     DPRINT1("EnumDependentServicesA is unimplemented\n");
 358     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 359     return FALSE;
 360 }
 361
 362
 363 /**********************************************************************
 364  *  EnumDependentServicesW
 365  *
 366  * @unimplemented
 367  */
 368 BOOL
 369 STDCALL
 370 EnumDependentServicesW(
 371     SC_HANDLE       hService,
 372     DWORD           dwServiceState,
 373     LPENUM_SERVICE_STATUSW  lpServices,
 374     DWORD           cbBufSize,
 375     LPDWORD         pcbBytesNeeded,
 376     LPDWORD         lpServicesReturned)
 377 {
 378     DPRINT1("EnumDependentServicesW is unimplemented\n");
 379     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 380     return FALSE;
 381 }
 382
 383
 384 /**********************************************************************
 385  *  EnumServiceGroupW
 386  *
 387  * @unimplemented
 388  */
 389 BOOL
 390 STDCALL
 391 EnumServiceGroupW (
 392     DWORD   Unknown0,
 393     DWORD   Unknown1,
 394     DWORD   Unknown2,
 395     DWORD   Unknown3,
 396     DWORD   Unknown4,
 397     DWORD   Unknown5,
 398     DWORD   Unknown6,
 399     DWORD   Unknown7,
 400     DWORD   Unknown8)
 401 {
 402     DPRINT1("EnumServiceGroupW is unimplemented\n");
 403     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 404     return FALSE;
 405 }
 406
 407
 408 /**********************************************************************
 409  *  EnumServicesStatusA
 410  *
 411  * @unimplemented
 412  */
 413 BOOL
 414 STDCALL
 415 EnumServicesStatusA (
 416     SC_HANDLE               hSCManager,
 417     DWORD                   dwServiceType,
 418     DWORD                   dwServiceState,
 419     LPENUM_SERVICE_STATUSA  lpServices,
 420     DWORD                   cbBufSize,
 421     LPDWORD                 pcbBytesNeeded,
 422     LPDWORD                 lpServicesReturned,
 423     LPDWORD                 lpResumeHandle)
 424 {
 425     DPRINT1("EnumServicesStatusA is unimplemented\n");
 426     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 427     return FALSE;
 428 }
 429
 430
 431 /**********************************************************************
 432  *  EnumServicesStatusExA
 433  *
 434  * @unimplemented
 435  */
 436 BOOL
 437 STDCALL
 438 EnumServicesStatusExA(SC_HANDLE  hSCManager,
 439   SC_ENUM_TYPE  InfoLevel,
 440   DWORD  dwServiceType,
 441   DWORD  dwServiceState,
 442   LPBYTE  lpServices,
 443   DWORD  cbBufSize,
 444   LPDWORD  pcbBytesNeeded,
 445   LPDWORD  lpServicesReturned,
 446   LPDWORD  lpResumeHandle,
 447   LPCSTR  pszGroupName)
 448 {
 449     DPRINT1("EnumServicesStatusExA is unimplemented\n");
 450     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 451     return FALSE;
 452 }
 453
 454
 455 /**********************************************************************
 456  *  EnumServicesStatusExW
 457  *
 458  * @unimplemented
 459  */
 460 BOOL
 461 STDCALL
 462 EnumServicesStatusExW(SC_HANDLE  hSCManager,
 463   SC_ENUM_TYPE  InfoLevel,
 464   DWORD  dwServiceType,
 465   DWORD  dwServiceState,
 466   LPBYTE  lpServices,
 467   DWORD  cbBufSize,
 468   LPDWORD  pcbBytesNeeded,
 469   LPDWORD  lpServicesReturned,
 470   LPDWORD  lpResumeHandle,
 471   LPCWSTR  pszGroupName)
 472 {
 473     DPRINT1("EnumServicesStatusExW is unimplemented\n");
 474     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 475     return FALSE;
 476 }
 477
 478
 479 /**********************************************************************
 480  *  EnumServicesStatusW
 481  *
 482  * @unimplemented
 483  */
 484 BOOL
 485 STDCALL
 486 EnumServicesStatusW(
 487     SC_HANDLE               hSCManager,
 488     DWORD                   dwServiceType,
 489     DWORD                   dwServiceState,
 490     LPENUM_SERVICE_STATUSW  lpServices,
 491     DWORD                   cbBufSize,
 492     LPDWORD                 pcbBytesNeeded,
 493     LPDWORD                 lpServicesReturned,
 494     LPDWORD                 lpResumeHandle)
 495 {
 496     DPRINT1("EnumServicesStatusW is unimplemented\n");
 497     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 498     return FALSE;
 499 }
 500
 501
 502 /**********************************************************************
 503  *  GetServiceDisplayNameA
 504  *
 505  * @unimplemented
 506  */
 507 BOOL
 508 STDCALL
 509 GetServiceDisplayNameA(
 510     SC_HANDLE   hSCManager,
 511     LPCSTR      lpServiceName,
 512     LPSTR       lpDisplayName,
 513     LPDWORD     lpcchBuffer)
 514 {
 515     DPRINT1("GetServiceDisplayNameA is unimplemented\n");
 516     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 517     return FALSE;
 518 }
 519
 520
 521 /**********************************************************************
 522  *  GetServiceDisplayNameW
 523  *
 524  * @unimplemented
 525  */
 526 BOOL
 527 STDCALL
 528 GetServiceDisplayNameW(
 529     SC_HANDLE   hSCManager,
 530     LPCWSTR     lpServiceName,
 531     LPWSTR      lpDisplayName,
 532     LPDWORD     lpcchBuffer)
 533 {
 534     DPRINT1("GetServiceDisplayNameW is unimplemented\n");
 535     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 536     return FALSE;
 537 }
 538
 539
 540 /**********************************************************************
 541  *  GetServiceKeyNameA
 542  *
 543  * @unimplemented
 544  */
 545 BOOL
 546 STDCALL
 547 GetServiceKeyNameA(
 548     SC_HANDLE   hSCManager,
 549     LPCSTR      lpDisplayName,
 550     LPSTR       lpServiceName,
 551     LPDWORD     lpcchBuffer)
 552 {
 553     DPRINT1("GetServiceKeyNameA is unimplemented\n");
 554     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 555     return FALSE;
 556 }
 557
 558
 559 /**********************************************************************
 560  *  GetServiceKeyNameW
 561  *
 562  * @unimplemented
 563  */
 564 BOOL
 565 STDCALL
 566 GetServiceKeyNameW(
 567     SC_HANDLE   hSCManager,
 568     LPCWSTR     lpDisplayName,
 569     LPWSTR      lpServiceName,
 570     LPDWORD     lpcchBuffer)
 571 {
 572     DPRINT1("GetServiceKeyNameW is unimplemented\n");
 573     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 574     return FALSE;
 575 }
 576
 577
 578 /**********************************************************************
 579  *  LockServiceDatabase
 580  *
 581  * @implemented
 582  */
 583 SC_LOCK STDCALL
 584 LockServiceDatabase(SC_HANDLE hSCManager)
 585 {
 586   SC_LOCK hLock;
 587   DWORD dwError;
 588
 589   DPRINT("LockServiceDatabase(%x)\n", hSCManager);
 590
 591   HandleBind();
 592
 593   /* Call to services.exe using RPC */
 594   dwError = ScmrLockServiceDatabase(BindingHandle,
 595                                     (unsigned int)hSCManager,
 596                                     (unsigned int *)&hLock);
 597   if (dwError != ERROR_SUCCESS)
 598   {
 599     DPRINT1("ScmrLockServiceDatabase() failed (Error %lu)\n", dwError);
 600     SetLastError(dwError);
 601     return NULL;
 602   }
 603
 604   DPRINT("hLock = %p\n", hLock);
 605
 606   return hLock;
 607 }
 608
 609
 610 static VOID
 611 WaitForSCManager(VOID)
 612 {
 613   HANDLE hEvent;
 614
 615   DPRINT("WaitForSCManager() called\n");
 616
 617   /* Try to open the existing event */
 618   hEvent = OpenEventW(SYNCHRONIZE,
 619                       FALSE,
 620                       L"SvcctrlStartEvent_A3725DX");
 621   if (hEvent == NULL)
 622   {
 623     if (GetLastError() != ERROR_FILE_NOT_FOUND)
 624       return;
 625
 626     /* Try to create a new event */
 627     hEvent = CreateEventW(NULL,
 628                           TRUE,
 629                           FALSE,
 630                           L"SvcctrlStartEvent_A3725DX");
 631     if (hEvent == NULL)
 632     {
 633       /* Try to open the existing event again */
 634       hEvent = OpenEventW(SYNCHRONIZE,
 635                           FALSE,
 636                           L"SvcctrlStartEvent_A3725DX");
 637       if (hEvent == NULL)
 638         return;
 639     }
 640   }
 641
 642   /* Wait for 3 minutes */
 643   WaitForSingleObject(hEvent, 180000);
 644   CloseHandle(hEvent);
 645
 646   DPRINT("ScmWaitForSCManager() done\n");
 647 }
 648
 649
 650 /**********************************************************************
 651  *  OpenSCManagerA
 652  *
 653  * @implemented
 654  */
 655 SC_HANDLE STDCALL
 656 OpenSCManagerA(LPCSTR lpMachineName,
 657                LPCSTR lpDatabaseName,
 658                DWORD dwDesiredAccess)
 659 {
 660   SC_HANDLE hScm = NULL;
 661   DWORD dwError;
 662
 663   DPRINT("OpenSCManagerA(%s, %s, %lx)\n",
 664          lpMachineName, lpDatabaseName, dwDesiredAccess);
 665
 666   WaitForSCManager();
 667
 668   HandleBind();
 669
 670   /* Call to services.exe using RPC */
 671   dwError = ScmrOpenSCManagerA(BindingHandle,
 672                                (LPSTR)lpMachineName,
 673                                (LPSTR)lpDatabaseName,
 674                                dwDesiredAccess,
 675                                (unsigned int*)&hScm);
 676   if (dwError != ERROR_SUCCESS)
 677   {
 678     DPRINT1("ScmrOpenSCManagerA() failed (Error %lu)\n", dwError);
 679     SetLastError(dwError);
 680     return NULL;
 681   }
 682
 683   DPRINT("hScm = %p\n", hScm);
 684
 685   return hScm;
 686 }
 687
 688
 689 /**********************************************************************
 690  *  OpenSCManagerW
 691  *
 692  * @implemented
 693  */
 694 SC_HANDLE STDCALL
 695 OpenSCManagerW(LPCWSTR lpMachineName,
 696                LPCWSTR lpDatabaseName,
 697                DWORD dwDesiredAccess)
 698 {
 699   SC_HANDLE hScm = NULL;
 700   DWORD dwError;
 701
 702   DPRINT("OpenSCManagerW(%S, %S, %lx)\n",
 703          lpMachineName, lpDatabaseName, dwDesiredAccess);
 704
 705   WaitForSCManager();
 706
 707   HandleBind();
 708
 709   /* Call to services.exe using RPC */
 710   dwError = ScmrOpenSCManagerW(BindingHandle,
 711                                (LPWSTR)lpMachineName,
 712                                (LPWSTR)lpDatabaseName,
 713                                dwDesiredAccess,
 714                                (unsigned int*)&hScm);
 715   if (dwError != ERROR_SUCCESS)
 716   {
 717     DPRINT1("ScmrOpenSCManagerW() failed (Error %lu)\n", dwError);
 718     SetLastError(dwError);
 719     return NULL;
 720   }
 721
 722   DPRINT("hScm = %p\n", hScm);
 723
 724   return hScm;
 725 }
 726
 727
 728 /**********************************************************************
 729  *  OpenServiceA
 730  *
 731  * @implemented
 732  */
 733 SC_HANDLE STDCALL
 734 OpenServiceA(SC_HANDLE hSCManager,
 735              LPCSTR lpServiceName,
 736              DWORD dwDesiredAccess)
 737 {
 738   SC_HANDLE hService = NULL;
 739   DWORD dwError;
 740
 741   DPRINT("OpenServiceA(%p, %s, %lx)\n",
 742          hSCManager, lpServiceName, dwDesiredAccess);
 743
 744   HandleBind();
 745
 746   /* Call to services.exe using RPC */
 747   dwError = ScmrOpenServiceA(BindingHandle,
 748                              (unsigned int)hSCManager,
 749                              (LPSTR)lpServiceName,
 750                              dwDesiredAccess,
 751                              (unsigned int*)&hService);
 752   if (dwError != ERROR_SUCCESS)
 753   {
 754     DPRINT1("ScmrOpenServiceA() failed (Error %lu)\n", dwError);
 755     SetLastError(dwError);
 756     return NULL;
 757   }
 758
 759   DPRINT("hService = %p\n", hService);
 760
 761   return hService;
 762 }
 763
 764
 765 /**********************************************************************
 766  *  OpenServiceW
 767  *
 768  * @implemented
 769  */
 770 SC_HANDLE STDCALL
 771 OpenServiceW(SC_HANDLE hSCManager,
 772              LPCWSTR lpServiceName,
 773              DWORD dwDesiredAccess)
 774 {
 775   SC_HANDLE hService = NULL;
 776   DWORD dwError;
 777
 778   DPRINT("OpenServiceW(%p, %S, %lx)\n",
 779          hSCManager, lpServiceName, dwDesiredAccess);
 780
 781   HandleBind();
 782
 783   /* Call to services.exe using RPC */
 784   dwError = ScmrOpenServiceW(BindingHandle,
 785                              (unsigned int)hSCManager,
 786                              (LPWSTR)lpServiceName,
 787                              dwDesiredAccess,
 788                              (unsigned int*)&hService);
 789   if (dwError != ERROR_SUCCESS)
 790   {
 791     DPRINT1("ScmrOpenServiceW() failed (Error %lu)\n", dwError);
 792     SetLastError(dwError);
 793     return NULL;
 794   }
 795
 796   DPRINT("hService = %p\n", hService);
 797
 798   return hService;
 799 }
 800
 801
 802 /**********************************************************************
 803  *  QueryServiceConfigA
 804  *
 805  * @unimplemented
 806  */
 807 BOOL
 808 STDCALL
 809 QueryServiceConfigA(
 810     SC_HANDLE       hService,
 811     LPQUERY_SERVICE_CONFIGA lpServiceConfig,
 812     DWORD           cbBufSize,
 813     LPDWORD         pcbBytesNeeded)
 814 {
 815     DPRINT1("QueryServiceConfigA is unimplemented\n");
 816     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 817     return FALSE;
 818 }
 819
 820
 821 /**********************************************************************
 822  *  QueryServiceConfigW
 823  *
 824  * @unimplemented
 825  */
 826 BOOL
 827 STDCALL
 828 QueryServiceConfigW(
 829     SC_HANDLE       hService,
 830     LPQUERY_SERVICE_CONFIGW lpServiceConfig,
 831     DWORD                   cbBufSize,
 832     LPDWORD                 pcbBytesNeeded)
 833 {
 834     DPRINT1("QueryServiceConfigW is unimplemented\n");
 835     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 836     return FALSE;
 837 }
 838
 839
 840 /**********************************************************************
 841  *  QueryServiceLockStatusA
 842  *
 843  * @unimplemented
 844  */
 845 BOOL
 846 STDCALL
 847 QueryServiceLockStatusA(
 848     SC_HANDLE           hSCManager,
 849     LPQUERY_SERVICE_LOCK_STATUSA    lpLockStatus,
 850     DWORD               cbBufSize,
 851     LPDWORD             pcbBytesNeeded)
 852 {
 853     DPRINT1("QueryServiceLockStatusA is unimplemented\n");
 854     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 855     return FALSE;
 856 }
 857
 858
 859 /**********************************************************************
 860  *  QueryServiceLockStatusW
 861  *
 862  * @unimplemented
 863  */
 864 BOOL
 865 STDCALL
 866 QueryServiceLockStatusW(
 867     SC_HANDLE           hSCManager,
 868     LPQUERY_SERVICE_LOCK_STATUSW    lpLockStatus,
 869     DWORD               cbBufSize,
 870     LPDWORD             pcbBytesNeeded)
 871 {
 872     DPRINT1("QueryServiceLockStatusW is unimplemented\n");
 873     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 874     return FALSE;
 875 }
 876
 877
 878 /**********************************************************************
 879  *  QueryServiceObjectSecurity
 880  *
 881  * @unimplemented
 882  */
 883 BOOL
 884 STDCALL
 885 QueryServiceObjectSecurity(
 886     SC_HANDLE       hService,
 887     SECURITY_INFORMATION    dwSecurityInformation,
 888     PSECURITY_DESCRIPTOR    lpSecurityDescriptor,
 889     DWORD           cbBufSize,
 890     LPDWORD         pcbBytesNeeded)
 891 {
 892     DPRINT1("QueryServiceObjectSecurity is unimplemented\n");
 893     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 894     return FALSE;
 895 }
 896
 897
 898 /**********************************************************************
 899  *  QueryServiceStatus
 900  *
 901  * @implemented
 902  */
 903 BOOL STDCALL
 904 QueryServiceStatus(SC_HANDLE hService,
 905                    LPSERVICE_STATUS lpServiceStatus)
 906 {
 907   DWORD dwError;
 908
 909   DPRINT("QueryServiceStatus(%p, %p)\n",
 910          hService, lpServiceStatus);
 911
 912   HandleBind();
 913
 914   /* Call to services.exe using RPC */
 915   dwError = ScmrQueryServiceStatus(BindingHandle,
 916                                    (unsigned int)hService,
 917                                    lpServiceStatus);
 918   if (dwError != ERROR_SUCCESS)
 919   {
 920     DPRINT1("ScmrQueryServiceStatus() failed (Error %lu)\n", dwError);
 921     SetLastError(dwError);
 922     return FALSE;
 923   }
 924
 925   return TRUE;
 926 }
 927
 928
 929 /**********************************************************************
 930  *  QueryServiceStatusEx
 931  *
 932  * @unimplemented
 933  */
 934 BOOL
 935 STDCALL
 936 QueryServiceStatusEx(SC_HANDLE  hService,
 937   SC_STATUS_TYPE  InfoLevel,
 938   LPBYTE  lpBuffer,
 939   DWORD  cbBufSize,
 940   LPDWORD  pcbBytesNeeded)
 941 {
 942     DPRINT1("QueryServiceStatusEx is unimplemented\n");
 943     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 944     return FALSE;
 945 }
 946
 947
 948 /**********************************************************************
 949  *  StartServiceA
 950  *
 951  * @unimplemented
 952  */
 953 BOOL
 954 STDCALL
 955 StartServiceA(
 956     SC_HANDLE   hService,
 957     DWORD       dwNumServiceArgs,
 958     LPCSTR      *lpServiceArgVectors)
 959 {
 960     DPRINT1("StartServiceA is unimplemented\n");
 961     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 962     return FALSE;
 963 }
 964
 965
 966 /**********************************************************************
 967  *  StartServiceW
 968  *
 969  * @unimplemented
 970  */
 971 BOOL
 972 STDCALL
 973 StartServiceW(
 974     SC_HANDLE   hService,
 975     DWORD       dwNumServiceArgs,
 976     LPCWSTR     *lpServiceArgVectors)
 977 {
 978     DPRINT1("StartServiceW is unimplemented\n");
 979     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 980     return FALSE;
 981 }
 982
 983
 984 /**********************************************************************
 985  *  UnlockServiceDatabase
 986  *
 987  * @implemented
 988  */
 989 BOOL STDCALL
 990 UnlockServiceDatabase(SC_LOCK ScLock)
 991 {
 992   DWORD dwError;
 993
 994 #if 0
 995   DPRINT("UnlockServiceDatabase(%x)\n", hSCManager);
 996 #endif
 997
 998   HandleBind();
 999
1000   /* Call to services.exe using RPC */
1001   dwError = ScmrUnlockServiceDatabase(BindingHandle,
1002                                       (unsigned int)ScLock);
1003   if (dwError != ERROR_SUCCESS)
1004   {
1005     DPRINT1("ScmrUnlockServiceDatabase() failed (Error %lu)\n", dwError);
1006     SetLastError(dwError);
1007     return FALSE;
1008   }
1009
1010   return TRUE;
1011 }
1012
1013
1014 void __RPC_FAR * __RPC_USER midl_user_allocate(size_t len)
1015 {
1016   return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
1017 }
1018
1019 void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
1020 {
1021   HeapFree(GetProcessHeap(), 0, ptr);
1022 }
1023
1024 /* EOF */