reactos/lib/advapi32/service/scm.c

   1 /* $Id: scm.c,v 1.24 2004/09/26 20:28:22 gvg Exp $
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS system libraries
   5  * FILE:            lib/advapi32/service/scm.c
   6  * PURPOSE:         Service control manager functions
   7  * PROGRAMMER:      Emanuele Aliberti
   8  * UPDATE HISTORY:
   9  *  19990413 EA created
  10  *  19990515 EA
  11  */
  12
  13 /* INCLUDES ******************************************************************/
  14
  15 #include "advapi32.h"
  16 #define NDEBUG
  17 #include <debug.h>
  18
  19 /* FUNCTIONS *****************************************************************/
  20
  21 /**********************************************************************
  22  *  ChangeServiceConfigA
  23  *
  24  * @unimplemented
  25  */
  26 BOOL
  27 STDCALL
  28 ChangeServiceConfigA(
  29     SC_HANDLE   hService,
  30     DWORD       dwServiceType,
  31     DWORD       dwStartType,
  32     DWORD       dwErrorControl,
  33     LPCSTR      lpBinaryPathName,
  34     LPCSTR      lpLoadOrderGroup,
  35     LPDWORD     lpdwTagId,
  36     LPCSTR      lpDependencies,
  37     LPCSTR      lpServiceStartName,
  38     LPCSTR      lpPassword,
  39     LPCSTR      lpDisplayName)
  40 {
  41     DPRINT1("ChangeServiceConfigA is unimplemented\n");
  42     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  43     return FALSE;
  44 }
  45
  46
  47 /**********************************************************************
  48  *  ChangeServiceConfigW
  49  *
  50  * @unimplemented
  51  */
  52 BOOL
  53 STDCALL
  54 ChangeServiceConfigW(
  55     SC_HANDLE   hService,
  56     DWORD       dwServiceType,
  57     DWORD       dwStartType,
  58     DWORD       dwErrorControl,
  59     LPCWSTR     lpBinaryPathName,
  60     LPCWSTR     lpLoadOrderGroup,
  61     LPDWORD     lpdwTagId,
  62     LPCWSTR     lpDependencies,
  63     LPCWSTR     lpServiceStartName,
  64     LPCWSTR     lpPassword,
  65     LPCWSTR     lpDisplayName)
  66 {
  67     DPRINT1("ChangeServiceConfigW is unimplemented\n");
  68     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  69     return FALSE;
  70 }
  71
  72
  73 /**********************************************************************
  74  *  CloseServiceHandle
  75  *
  76  * @implemented
  77  */
  78 BOOL
  79 STDCALL
  80 CloseServiceHandle(SC_HANDLE hSCObject)
  81 {
  82     DPRINT("CloseServiceHandle() - called.\n");
  83
  84     if (!CloseHandle(hSCObject)) {
  85         SetLastError(ERROR_INVALID_HANDLE);
  86         return FALSE;
  87     }
  88     return TRUE;
  89 }
  90
  91
  92 /**********************************************************************
  93  *  ControlService
  94  *
  95  * @unimplemented
  96  */
  97 BOOL
  98 STDCALL
  99 ControlService(SC_HANDLE        hService,
 100                DWORD            dwControl,
 101                LPSERVICE_STATUS lpServiceStatus)
 102 {
 103     DPRINT1("ControlService is unimplemented\n");
 104     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 105     return FALSE;
 106 }
 107
 108
 109 /**********************************************************************
 110  *  CreateServiceA
 111  *
 112  * @unimplemented
 113  */
 114 SC_HANDLE
 115 STDCALL
 116 CreateServiceA(
 117     SC_HANDLE   hSCManager,
 118     LPCSTR      lpServiceName,
 119     LPCSTR      lpDisplayName,
 120     DWORD       dwDesiredAccess,
 121     DWORD       dwServiceType,
 122     DWORD       dwStartType,
 123     DWORD       dwErrorControl,
 124     LPCSTR      lpBinaryPathName,
 125     LPCSTR      lpLoadOrderGroup,
 126     LPDWORD     lpdwTagId,
 127     LPCSTR      lpDependencies,
 128     LPCSTR      lpServiceStartName,
 129     LPCSTR      lpPassword)
 130 {
 131     DPRINT1("CreateServiceA is unimplemented, but returning INVALID_HANDLE_VALUE instead of NULL\n");
 132     return INVALID_HANDLE_VALUE;
 133 }
 134
 135
 136 /**********************************************************************
 137  *  CreateServiceW
 138  *
 139  * @unimplemented
 140  */
 141 SC_HANDLE
 142 STDCALL
 143 CreateServiceW(
 144     SC_HANDLE   hSCManager,
 145     LPCWSTR     lpServiceName,
 146     LPCWSTR     lpDisplayName,
 147     DWORD       dwDesiredAccess,
 148     DWORD       dwServiceType,
 149     DWORD       dwStartType,
 150     DWORD       dwErrorControl,
 151     LPCWSTR     lpBinaryPathName,
 152     LPCWSTR     lpLoadOrderGroup,
 153     LPDWORD     lpdwTagId,
 154     LPCWSTR     lpDependencies,
 155     LPCWSTR     lpServiceStartName,
 156     LPCWSTR     lpPassword)
 157 {
 158     DPRINT1("CreateServiceW is unimplemented, but returning INVALID_HANDLE_VALUE instead of NULL\n");
 159     return INVALID_HANDLE_VALUE;
 160 }
 161
 162
 163 /**********************************************************************
 164  *  DeleteService
 165  *
 166  * @unimplemented
 167  */
 168 BOOL
 169 STDCALL
 170 DeleteService(SC_HANDLE hService)
 171 {
 172     DPRINT1("DeleteService is unimplemented\n");
 173     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 174     return FALSE;
 175 }
 176
 177
 178 /**********************************************************************
 179  *  EnumDependentServicesA
 180  *
 181  * @unimplemented
 182  */
 183 BOOL
 184 STDCALL
 185 EnumDependentServicesA(
 186     SC_HANDLE       hService,
 187     DWORD           dwServiceState,
 188     LPENUM_SERVICE_STATUSA  lpServices,
 189     DWORD           cbBufSize,
 190     LPDWORD         pcbBytesNeeded,
 191     LPDWORD         lpServicesReturned)
 192 {
 193     DPRINT1("EnumDependentServicesA is unimplemented\n");
 194     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 195     return FALSE;
 196 }
 197
 198
 199 /**********************************************************************
 200  *  EnumDependentServicesW
 201  *
 202  * @unimplemented
 203  */
 204 BOOL
 205 STDCALL
 206 EnumDependentServicesW(
 207     SC_HANDLE       hService,
 208     DWORD           dwServiceState,
 209     LPENUM_SERVICE_STATUSW  lpServices,
 210     DWORD           cbBufSize,
 211     LPDWORD         pcbBytesNeeded,
 212     LPDWORD         lpServicesReturned)
 213 {
 214     DPRINT1("EnumDependentServicesW is unimplemented\n");
 215     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 216     return FALSE;
 217 }
 218
 219
 220 /**********************************************************************
 221  *  EnumServiceGroupW
 222  *
 223  * @unimplemented
 224  */
 225 BOOL
 226 STDCALL
 227 EnumServiceGroupW (
 228     DWORD   Unknown0,
 229     DWORD   Unknown1,
 230     DWORD   Unknown2,
 231     DWORD   Unknown3,
 232     DWORD   Unknown4,
 233     DWORD   Unknown5,
 234     DWORD   Unknown6,
 235     DWORD   Unknown7,
 236     DWORD   Unknown8)
 237 {
 238     DPRINT1("EnumServiceGroupW is unimplemented\n");
 239     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 240     return FALSE;
 241 }
 242
 243
 244 /**********************************************************************
 245  *  EnumServicesStatusA
 246  *
 247  * @unimplemented
 248  */
 249 BOOL
 250 STDCALL
 251 EnumServicesStatusA (
 252     SC_HANDLE               hSCManager,
 253     DWORD                   dwServiceType,
 254     DWORD                   dwServiceState,
 255     LPENUM_SERVICE_STATUSA  lpServices,
 256     DWORD                   cbBufSize,
 257     LPDWORD                 pcbBytesNeeded,
 258     LPDWORD                 lpServicesReturned,
 259     LPDWORD                 lpResumeHandle)
 260 {
 261     DPRINT1("EnumServicesStatusA is unimplemented\n");
 262     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 263     return FALSE;
 264 }
 265
 266
 267 /**********************************************************************
 268  *  EnumServicesStatusExA
 269  *
 270  * @unimplemented
 271  */
 272 BOOL
 273 STDCALL
 274 EnumServicesStatusExA(SC_HANDLE  hSCManager,
 275   SC_ENUM_TYPE  InfoLevel,
 276   DWORD  dwServiceType,
 277   DWORD  dwServiceState,
 278   LPBYTE  lpServices,
 279   DWORD  cbBufSize,
 280   LPDWORD  pcbBytesNeeded,
 281   LPDWORD  lpServicesReturned,
 282   LPDWORD  lpResumeHandle,
 283   LPCSTR  pszGroupName)
 284 {
 285     DPRINT1("EnumServicesStatusExA is unimplemented\n");
 286     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 287     return FALSE;
 288 }
 289
 290
 291 /**********************************************************************
 292  *  EnumServicesStatusExW
 293  *
 294  * @unimplemented
 295  */
 296 BOOL
 297 STDCALL
 298 EnumServicesStatusExW(SC_HANDLE  hSCManager,
 299   SC_ENUM_TYPE  InfoLevel,
 300   DWORD  dwServiceType,
 301   DWORD  dwServiceState,
 302   LPBYTE  lpServices,
 303   DWORD  cbBufSize,
 304   LPDWORD  pcbBytesNeeded,
 305   LPDWORD  lpServicesReturned,
 306   LPDWORD  lpResumeHandle,
 307   LPCWSTR  pszGroupName)
 308 {
 309     DPRINT1("EnumServicesStatusExW is unimplemented\n");
 310     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 311     return FALSE;
 312 }
 313
 314
 315 /**********************************************************************
 316  *  EnumServicesStatusW
 317  *
 318  * @unimplemented
 319  */
 320 BOOL
 321 STDCALL
 322 EnumServicesStatusW(
 323     SC_HANDLE               hSCManager,
 324     DWORD                   dwServiceType,
 325     DWORD                   dwServiceState,
 326     LPENUM_SERVICE_STATUSW  lpServices,
 327     DWORD                   cbBufSize,
 328     LPDWORD                 pcbBytesNeeded,
 329     LPDWORD                 lpServicesReturned,
 330     LPDWORD                 lpResumeHandle)
 331 {
 332     DPRINT1("EnumServicesStatusW is unimplemented\n");
 333     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 334     return FALSE;
 335 }
 336
 337
 338 /**********************************************************************
 339  *  GetServiceDisplayNameA
 340  *
 341  * @unimplemented
 342  */
 343 BOOL
 344 STDCALL
 345 GetServiceDisplayNameA(
 346     SC_HANDLE   hSCManager,
 347     LPCSTR      lpServiceName,
 348     LPSTR       lpDisplayName,
 349     LPDWORD     lpcchBuffer)
 350 {
 351     DPRINT1("GetServiceDisplayNameA is unimplemented\n");
 352     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 353     return FALSE;
 354 }
 355
 356
 357 /**********************************************************************
 358  *  GetServiceDisplayNameW
 359  *
 360  * @unimplemented
 361  */
 362 BOOL
 363 STDCALL
 364 GetServiceDisplayNameW(
 365     SC_HANDLE   hSCManager,
 366     LPCWSTR     lpServiceName,
 367     LPWSTR      lpDisplayName,
 368     LPDWORD     lpcchBuffer)
 369 {
 370     DPRINT1("GetServiceDisplayNameW is unimplemented\n");
 371     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 372     return FALSE;
 373 }
 374
 375
 376 /**********************************************************************
 377  *  GetServiceKeyNameA
 378  *
 379  * @unimplemented
 380  */
 381 BOOL
 382 STDCALL
 383 GetServiceKeyNameA(
 384     SC_HANDLE   hSCManager,
 385     LPCSTR      lpDisplayName,
 386     LPSTR       lpServiceName,
 387     LPDWORD     lpcchBuffer)
 388 {
 389     DPRINT1("GetServiceKeyNameA is unimplemented\n");
 390     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 391     return FALSE;
 392 }
 393
 394
 395 /**********************************************************************
 396  *  GetServiceKeyNameW
 397  *
 398  * @unimplemented
 399  */
 400 BOOL
 401 STDCALL
 402 GetServiceKeyNameW(
 403     SC_HANDLE   hSCManager,
 404     LPCWSTR     lpDisplayName,
 405     LPWSTR      lpServiceName,
 406     LPDWORD     lpcchBuffer)
 407 {
 408     DPRINT1("GetServiceKeyNameW is unimplemented\n");
 409     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 410     return FALSE;
 411 }
 412
 413 /**********************************************************************
 414  *  LockServiceDatabase
 415  *
 416  * @unimplemented
 417  */
 418 SC_LOCK
 419 STDCALL
 420 LockServiceDatabase(SC_HANDLE   hSCManager)
 421 {
 422     DPRINT1("LockServiceDatabase is unimplemented\n");
 423     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 424     return NULL;
 425 }
 426
 427
 428 /**********************************************************************
 429  *  OpenSCManagerA
 430  *
 431  * @unplemented
 432  */
 433 SC_HANDLE STDCALL
 434 OpenSCManagerA(LPCSTR lpMachineName,
 435            LPCSTR lpDatabaseName,
 436            DWORD dwDesiredAccess)
 437 {
 438   SC_HANDLE Handle;
 439   UNICODE_STRING MachineNameW;
 440   UNICODE_STRING DatabaseNameW;
 441   ANSI_STRING MachineNameA;
 442   ANSI_STRING DatabaseNameA;
 443
 444   DPRINT("OpenSCManagerA(%x, %x, %d)\n", lpMachineName, lpDatabaseName, dwDesiredAccess);
 445
 446   RtlInitAnsiString(&MachineNameA, (LPSTR)lpMachineName);
 447   RtlAnsiStringToUnicodeString(&MachineNameW, &MachineNameA, TRUE);
 448   RtlInitAnsiString(&DatabaseNameA, (LPSTR)lpDatabaseName);
 449   RtlAnsiStringToUnicodeString(&DatabaseNameW, &DatabaseNameA, TRUE);
 450
 451   Handle = OpenSCManagerW(lpMachineName ? MachineNameW.Buffer : NULL,
 452               lpDatabaseName ? DatabaseNameW.Buffer : NULL,
 453               dwDesiredAccess);
 454
 455   RtlFreeHeap(GetProcessHeap(), 0, MachineNameW.Buffer);
 456   RtlFreeHeap(GetProcessHeap(), 0, DatabaseNameW.Buffer);
 457   return Handle;
 458 }
 459
 460
 461 /**********************************************************************
 462  *  OpenSCManagerW
 463  *
 464  * @unimplemented
 465  */
 466 SC_HANDLE STDCALL OpenSCManagerW(LPCWSTR lpMachineName,
 467                                  LPCWSTR lpDatabaseName,
 468                                  DWORD dwDesiredAccess)
 469 {
 470   HANDLE hPipe;
 471   DWORD dwMode;
 472   DWORD dwWait;
 473   BOOL fSuccess;
 474   HANDLE hStartEvent;
 475   LPWSTR lpszPipeName = L"\\\\.\\pipe\\Ntsvcs";
 476
 477   DPRINT("OpenSCManagerW(%x, %x, %d)\n", lpMachineName, lpDatabaseName, dwDesiredAccess);
 478
 479   if (lpMachineName == NULL || wcslen(lpMachineName) == 0)
 480     {
 481       if (lpDatabaseName != NULL && wcscmp(lpDatabaseName, SERVICES_ACTIVE_DATABASEW) != 0)
 482         {
 483           DPRINT("OpenSCManagerW() - Invalid parameters.\n");
 484           return NULL;
 485         }
 486
 487       DPRINT("OpenSCManagerW() - OpenEvent(\"SvcctrlStartEvent_A3725DX\")\n");
 488
 489       // Only connect to scm when event "SvcctrlStartEvent_A3725DX" is signaled
 490       hStartEvent = OpenEventW(SYNCHRONIZE, FALSE, L"SvcctrlStartEvent_A3725DX");
 491       if (hStartEvent == NULL)
 492         {
 493           SetLastError(ERROR_DATABASE_DOES_NOT_EXIST);
 494           DPRINT("OpenSCManagerW() - Failed to Open Event \"SvcctrlStartEvent_A3725DX\".\n");
 495           return NULL;
 496         }
 497
 498       DPRINT("OpenSCManagerW() - Waiting forever on event handle: %x\n", hStartEvent);
 499
 500 #if 1
 501       dwWait = WaitForSingleObject(hStartEvent, INFINITE);
 502       if (dwWait == WAIT_FAILED)
 503         {
 504           DPRINT("OpenSCManagerW() - Wait For Start Event failed.\n");
 505           SetLastError(ERROR_ACCESS_DENIED);
 506           return NULL;
 507         }
 508 #else
 509         {
 510           DWORD Count;
 511
 512           /* wait for event creation (by SCM) for max. 20 seconds */
 513           for (Count = 0; Count < 20; Count++)
 514             {
 515               dwWait = WaitForSingleObject(hStartEvent, 1000);
 516               if (dwWait == WAIT_FAILED)
 517                 {
 518                   DPRINT("OpenSCManagerW() - Wait For Start Event failed.\n");
 519                   Sleep(1000);
 520                 }
 521               else
 522                 {
 523                   break;
 524                 }
 525             }
 526
 527           if (dwWait == WAIT_FAILED)
 528             {
 529               DbgPrint("WL: Failed to wait on event \"SvcctrlStartEvent_A3725DX\"\n");
 530             }
 531
 532         }
 533 #endif
 534
 535       DPRINT("OpenSCManagerW() - Closing handle to event...\n");
 536
 537       CloseHandle(hStartEvent);
 538
 539       // Try to open a named pipe; wait for it, if necessary
 540       while (1)
 541       {
 542         DWORD dwLastError;
 543         DPRINT("OpenSCManagerW() - attempting to open named pipe to SCM.\n");
 544         hPipe = CreateFileW(lpszPipeName,     // pipe name
 545             dwDesiredAccess,
 546             0,                // no sharing
 547             NULL,             // no security attributes
 548             OPEN_EXISTING,    // opens existing pipe
 549             0,                // default attributes
 550             NULL);            // no template file
 551
 552         DPRINT("OpenSCManagerW() - handle to named pipe: %x\n", hPipe);
 553         // Break if the pipe handle is valid
 554         if (hPipe != INVALID_HANDLE_VALUE)
 555           {
 556             break;
 557           }
 558
 559         // Exit if an error other than ERROR_PIPE_BUSY occurs
 560         dwLastError = GetLastError();
 561         if (dwLastError != ERROR_PIPE_BUSY)
 562           {
 563             DPRINT("OpenSCManagerW() - returning at 4, dwLastError %d\n", dwLastError);
 564             return NULL;
 565           }
 566
 567         // All pipe instances are busy, so wait for 20 seconds
 568         if (!WaitNamedPipeW(lpszPipeName, 20000))
 569           {
 570             DPRINT("OpenSCManagerW() - Failed on WaitNamedPipeW(...).\n");
 571             return NULL;
 572           }
 573       }
 574
 575       // The pipe connected; change to message-read mode
 576       dwMode = PIPE_READMODE_MESSAGE;
 577       fSuccess = SetNamedPipeHandleState(
 578           hPipe,    // pipe handle
 579           &dwMode,  // new pipe mode
 580           NULL,     // don't set maximum bytes
 581           NULL);    // don't set maximum time
 582       if (!fSuccess)
 583         {
 584           CloseHandle(hPipe);
 585           DPRINT("OpenSCManagerW() - Failed on SetNamedPipeHandleState(...).\n");
 586           return NULL;
 587         }
 588 #if 0
 589       // Send a message to the pipe server
 590       lpvMessage = (argc > 1) ? argv[1] : "default message";
 591
 592       fSuccess = WriteFile(
 593           hPipe,                  // pipe handle
 594           lpvMessage,             // message
 595           strlen(lpvMessage) + 1, // message length
 596           &cbWritten,             // bytes written
 597           NULL);                  // not overlapped
 598       if (!fSuccess)
 599         {
 600           CloseHandle(hPipe);
 601           DPRINT("OpenSCManagerW() - Failed to write to pipe.\n");
 602           return NULL;
 603         }
 604
 605       do
 606         {
 607           DPRINT("OpenSCManagerW() - in I/O loop to SCM...\n");
 608           // Read from the pipe
 609           fSuccess = ReadFile(
 610               hPipe,    // pipe handle
 611               chBuf,    // buffer to receive reply
 612               512,      // size of buffer
 613               &cbRead,  // number of bytes read
 614               NULL);    // not overlapped
 615
 616           if (!fSuccess && GetLastError() != ERROR_MORE_DATA)
 617             {
 618               break;
 619             }
 620
 621           // Reply from the pipe is written to STDOUT.
 622           if (!WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), chBuf, cbRead, &cbWritten, NULL))
 623             {
 624               break;
 625             }
 626         } while(!fSuccess);  // repeat loop if ERROR_MORE_DATA
 627
 628       DPRINT("OpenSCManagerW() - I/O loop completed.\n");
 629       //CloseHandle(hPipe);
 630 #endif
 631       DPRINT("OpenSCManagerW() - success, returning handle to pipe %x\n", hPipe);
 632       return hPipe;
 633     }
 634   else
 635     {
 636       /* FIXME: Connect to remote SCM */
 637       DPRINT("OpenSCManagerW() - FIXME: Connect to remote SCM is unimplemented.\n");
 638       return NULL;
 639     }
 640 }
 641
 642
 643 /**********************************************************************
 644  *  OpenServiceA
 645  *
 646  * @unimplemented
 647  */
 648 SC_HANDLE STDCALL
 649 OpenServiceA(SC_HANDLE hSCManager,
 650          LPCSTR  lpServiceName,
 651          DWORD dwDesiredAccess)
 652 {
 653   DPRINT1("OpenServiceA is unimplemented, returning ERROR_SERVICE_DOES_NOT_EXIST for %s\n", lpServiceName);
 654   SetLastError(ERROR_SERVICE_DOES_NOT_EXIST);
 655   return NULL;
 656 }
 657
 658
 659 /**********************************************************************
 660  *  OpenServiceW
 661  *
 662  * @unimplemented
 663  */
 664 SC_HANDLE
 665 STDCALL
 666 OpenServiceW(
 667     SC_HANDLE   hSCManager,
 668     LPCWSTR     lpServiceName,
 669     DWORD       dwDesiredAccess
 670     )
 671 {
 672   DPRINT1("OpenServiceW is unimplemented, returning ERROR_SERVICE_DOES_NOT_EXIST for %S\n", lpServiceName);
 673   SetLastError(ERROR_SERVICE_DOES_NOT_EXIST);
 674   return NULL;
 675 }
 676
 677
 678 /**********************************************************************
 679  *  QueryServiceConfigA
 680  *
 681  * @unimplemented
 682  */
 683 BOOL
 684 STDCALL
 685 QueryServiceConfigA(
 686     SC_HANDLE       hService,
 687     LPQUERY_SERVICE_CONFIGA lpServiceConfig,
 688     DWORD           cbBufSize,
 689     LPDWORD         pcbBytesNeeded)
 690 {
 691     DPRINT1("QueryServiceConfigA is unimplemented\n");
 692     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 693     return FALSE;
 694 }
 695
 696
 697 /**********************************************************************
 698  *  QueryServiceConfigW
 699  *
 700  * @unimplemented
 701  */
 702 BOOL
 703 STDCALL
 704 QueryServiceConfigW(
 705     SC_HANDLE       hService,
 706     LPQUERY_SERVICE_CONFIGW lpServiceConfig,
 707     DWORD                   cbBufSize,
 708     LPDWORD                 pcbBytesNeeded)
 709 {
 710     DPRINT1("QueryServiceConfigW is unimplemented\n");
 711     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 712     return FALSE;
 713 }
 714
 715
 716 /**********************************************************************
 717  *  QueryServiceLockStatusA
 718  *
 719  * @unimplemented
 720  */
 721 BOOL
 722 STDCALL
 723 QueryServiceLockStatusA(
 724     SC_HANDLE           hSCManager,
 725     LPQUERY_SERVICE_LOCK_STATUSA    lpLockStatus,
 726     DWORD               cbBufSize,
 727     LPDWORD             pcbBytesNeeded)
 728 {
 729     DPRINT1("QueryServiceLockStatusA is unimplemented\n");
 730     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 731     return FALSE;
 732 }
 733
 734
 735 /**********************************************************************
 736  *  QueryServiceLockStatusW
 737  *
 738  * @unimplemented
 739  */
 740 BOOL
 741 STDCALL
 742 QueryServiceLockStatusW(
 743     SC_HANDLE           hSCManager,
 744     LPQUERY_SERVICE_LOCK_STATUSW    lpLockStatus,
 745     DWORD               cbBufSize,
 746     LPDWORD             pcbBytesNeeded)
 747 {
 748     DPRINT1("QueryServiceLockStatusW is unimplemented\n");
 749     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 750     return FALSE;
 751 }
 752
 753
 754 /**********************************************************************
 755  *  QueryServiceObjectSecurity
 756  *
 757  * @unimplemented
 758  */
 759 BOOL
 760 STDCALL
 761 QueryServiceObjectSecurity(
 762     SC_HANDLE       hService,
 763     SECURITY_INFORMATION    dwSecurityInformation,
 764     PSECURITY_DESCRIPTOR    lpSecurityDescriptor,
 765     DWORD           cbBufSize,
 766     LPDWORD         pcbBytesNeeded)
 767 {
 768     DPRINT1("QueryServiceObjectSecurity is unimplemented\n");
 769     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 770     return FALSE;
 771 }
 772
 773
 774 /**********************************************************************
 775  *  QueryServiceStatus
 776  *
 777  * @unimplemented
 778  */
 779 BOOL
 780 STDCALL
 781 QueryServiceStatus(
 782     SC_HANDLE       hService,
 783     LPSERVICE_STATUS    lpServiceStatus)
 784 {
 785     DPRINT1("QueryServiceStatus is unimplemented\n");
 786     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 787     return FALSE;
 788 }
 789
 790
 791 /**********************************************************************
 792  *  QueryServiceStatusEx
 793  *
 794  * @unimplemented
 795  */
 796 BOOL
 797 STDCALL
 798 QueryServiceStatusEx(SC_HANDLE  hService,
 799   SC_STATUS_TYPE  InfoLevel,
 800   LPBYTE  lpBuffer,
 801   DWORD  cbBufSize,
 802   LPDWORD  pcbBytesNeeded)
 803 {
 804     DPRINT1("QueryServiceStatusEx is unimplemented\n");
 805     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 806     return FALSE;
 807 }
 808
 809
 810 /**********************************************************************
 811  *  StartServiceA
 812  *
 813  * @unimplemented
 814  */
 815 BOOL
 816 STDCALL
 817 StartServiceA(
 818     SC_HANDLE   hService,
 819     DWORD       dwNumServiceArgs,
 820     LPCSTR      *lpServiceArgVectors)
 821 {
 822     DPRINT1("StartServiceA is unimplemented\n");
 823     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 824     return FALSE;
 825 }
 826
 827
 828
 829
 830 /**********************************************************************
 831  *  StartServiceW
 832  *
 833  * @unimplemented
 834  */
 835 BOOL
 836 STDCALL
 837 StartServiceW(
 838     SC_HANDLE   hService,
 839     DWORD       dwNumServiceArgs,
 840     LPCWSTR     *lpServiceArgVectors)
 841 {
 842     DPRINT1("StartServiceW is unimplemented\n");
 843     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 844     return FALSE;
 845 }
 846
 847
 848 /**********************************************************************
 849  *  UnlockServiceDatabase
 850  *
 851  * @unimplemented
 852  */
 853 BOOL
 854 STDCALL
 855 UnlockServiceDatabase(SC_LOCK   ScLock)
 856 {
 857     DPRINT1("UnlockServiceDatabase is unimplemented\n");
 858     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 859     return FALSE;
 860 }
 861
 862
 863 /* EOF */