dlls/advapi32/service.c

   1 /*
   2  * Win32 advapi functions
   3  *
   4  * Copyright 1995 Sven Verdoolaege
   5  */
   6
   7 #include <time.h>
   8
   9 #include "windef.h"
  10 #include "winsvc.h"
  11 #include "winerror.h"
  12 #include "winreg.h"
  13 #include "heap.h"
  14 #include "debugtools.h"
  15
  16 DEFAULT_DEBUG_CHANNEL(advapi)
  17
  18 /******************************************************************************
  19  * EnumServicesStatus32A [ADVAPI32.38]
  20  */
  21 BOOL WINAPI
  22 EnumServicesStatusA( SC_HANDLE hSCManager, DWORD dwServiceType,
  23                        DWORD dwServiceState, LPENUM_SERVICE_STATUSA lpServices,
  24                        DWORD cbBufSize, LPDWORD pcbBytesNeeded,
  25                        LPDWORD lpServicesReturned, LPDWORD lpResumeHandle )
  26 {       FIXME("%x type=%lx state=%lx %p %lx %p %p %p\n", hSCManager,
  27                 dwServiceType, dwServiceState, lpServices, cbBufSize,
  28                 pcbBytesNeeded, lpServicesReturned,  lpResumeHandle);
  29         SetLastError (ERROR_ACCESS_DENIED);
  30         return 0;
  31 }
  32
  33 /******************************************************************************
  34  * StartServiceCtrlDispatcher32A [ADVAPI32.196]
  35  */
  36 BOOL WINAPI
  37 StartServiceCtrlDispatcherA( LPSERVICE_TABLE_ENTRYA servent )
  38 {       LPSERVICE_TABLE_ENTRYA ptr = servent;
  39
  40         while (ptr->lpServiceName)
  41         { FIXME("%s at %p\n", ptr->lpServiceName, ptr);
  42           ptr++;
  43         }
  44         return TRUE;
  45 }
  46
  47 /******************************************************************************
  48  * StartServiceCtrlDispatcher32W [ADVAPI32.197]
  49  *
  50  * PARAMS
  51  *   servent []
  52  */
  53 BOOL WINAPI
  54 StartServiceCtrlDispatcherW( LPSERVICE_TABLE_ENTRYW servent )
  55 {       LPSERVICE_TABLE_ENTRYW ptr = servent;
  56         LPSERVICE_MAIN_FUNCTIONW fpMain;
  57
  58         while (ptr->lpServiceName)
  59         { FIXME("%s at %p): STUB.\n", debugstr_w(ptr->lpServiceName),ptr);
  60           fpMain = ptr->lpServiceProc;
  61           fpMain(0,NULL);       /* try to start the service */
  62           ptr++;
  63         }
  64         return TRUE;
  65 }
  66
  67 /******************************************************************************
  68  * RegisterServiceCtrlHandlerA [ADVAPI32.176]
  69  */
  70 SERVICE_STATUS_HANDLE WINAPI
  71 RegisterServiceCtrlHandlerA( LPCSTR lpServiceName,
  72                              LPHANDLER_FUNCTION lpfHandler )
  73 {       FIXME("%s %p\n", lpServiceName, lpfHandler);
  74         return 0xcacacafe;
  75 }
  76
  77 /******************************************************************************
  78  * RegisterServiceCtrlHandlerW [ADVAPI32.177]
  79  *
  80  * PARAMS
  81  *   lpServiceName []
  82  *   lpfHandler    []
  83  */
  84 SERVICE_STATUS_HANDLE WINAPI
  85 RegisterServiceCtrlHandlerW( LPCWSTR lpServiceName,
  86                              LPHANDLER_FUNCTION lpfHandler )
  87 {       FIXME("%s %p\n", debugstr_w(lpServiceName), lpfHandler);
  88         return 0xcacacafe;
  89 }
  90
  91 /******************************************************************************
  92  * SetServiceStatus [ADVAPI32.192]
  93  *
  94  * PARAMS
  95  *   hService []
  96  *   lpStatus []
  97  */
  98 BOOL WINAPI
  99 SetServiceStatus( SERVICE_STATUS_HANDLE hService, LPSERVICE_STATUS lpStatus )
 100 {       FIXME("%lx %p\n",hService, lpStatus);
 101         TRACE("\tType:%lx\n",lpStatus->dwServiceType);
 102         TRACE("\tState:%lx\n",lpStatus->dwCurrentState);
 103         TRACE("\tControlAccepted:%lx\n",lpStatus->dwControlsAccepted);
 104         TRACE("\tExitCode:%lx\n",lpStatus->dwWin32ExitCode);
 105         TRACE("\tServiceExitCode:%lx\n",lpStatus->dwServiceSpecificExitCode);
 106         TRACE("\tCheckPoint:%lx\n",lpStatus->dwCheckPoint);
 107         TRACE("\tWaitHint:%lx\n",lpStatus->dwWaitHint);
 108         return TRUE;
 109 }
 110
 111 /******************************************************************************
 112  * OpenSCManager32A [ADVAPI32.110]
 113  */
 114 SC_HANDLE WINAPI
 115 OpenSCManagerA( LPCSTR lpMachineName, LPCSTR lpDatabaseName,
 116                   DWORD dwDesiredAccess )
 117 {
 118     LPWSTR lpMachineNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpMachineName);
 119     LPWSTR lpDatabaseNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpDatabaseName);
 120     DWORD ret = OpenSCManagerW(lpMachineNameW,lpDatabaseNameW,
 121                                  dwDesiredAccess);
 122     HeapFree(GetProcessHeap(),0,lpDatabaseNameW);
 123     HeapFree(GetProcessHeap(),0,lpMachineNameW);
 124     return ret;
 125 }
 126
 127 /******************************************************************************
 128  * OpenSCManager32W [ADVAPI32.111]
 129  * Establishes a connection to the service control manager and opens database
 130  *
 131  * NOTES
 132  *   This should return a SC_HANDLE
 133  *
 134  * PARAMS
 135  *   lpMachineName   [I] Pointer to machine name string
 136  *   lpDatabaseName  [I] Pointer to database name string
 137  *   dwDesiredAccess [I] Type of access
 138  *
 139  * RETURNS
 140  *   Success: Handle to service control manager database
 141  *   Failure: NULL
 142  */
 143 SC_HANDLE WINAPI
 144 OpenSCManagerW( LPCWSTR lpMachineName, LPCWSTR lpDatabaseName,
 145                   DWORD dwDesiredAccess )
 146 {
 147     HKEY hKey;
 148     LONG r;
 149
 150     TRACE("(%s,%s,0x%08lx)\n", debugstr_w(lpMachineName),
 151           debugstr_w(lpDatabaseName), dwDesiredAccess);
 152
 153     /*
 154      * FIXME: what is lpDatabaseName?
 155      * It should be set to "SERVICES_ACTIVE_DATABASE" according to
 156      * docs, but what if it isn't?
 157      */
 158
 159     r = RegConnectRegistryW(lpMachineName,HKEY_LOCAL_MACHINE,&hKey);
 160     if (r!=ERROR_SUCCESS)
 161         return 0;
 162
 163     TRACE("returning %x\n",hKey);
 164
 165     return hKey;
 166 }
 167
 168
 169 /******************************************************************************
 170  * AllocateLocallyUniqueId [ADVAPI32.12]
 171  *
 172  * PARAMS
 173  *   lpluid []
 174  */
 175 BOOL WINAPI
 176 AllocateLocallyUniqueId( PLUID lpluid )
 177 {
 178         lpluid->s.LowPart = time(NULL);
 179         lpluid->s.HighPart = 0;
 180         return TRUE;
 181 }
 182
 183
 184 /******************************************************************************
 185  * ControlService [ADVAPI32.23]
 186  * Sends a control code to a Win32-based service.
 187  *
 188  * PARAMS
 189  *   hService        []
 190  *   dwControl       []
 191  *   lpServiceStatus []
 192  *
 193  * RETURNS STD
 194  */
 195 BOOL WINAPI
 196 ControlService( SC_HANDLE hService, DWORD dwControl,
 197                 LPSERVICE_STATUS lpServiceStatus )
 198 {
 199     FIXME("(%d,%ld,%p): stub\n",hService,dwControl,lpServiceStatus);
 200     return TRUE;
 201 }
 202
 203
 204 /******************************************************************************
 205  * CloseServiceHandle [ADVAPI32.22]
 206  * Close handle to service or service control manager
 207  *
 208  * PARAMS
 209  *   hSCObject [I] Handle to service or service control manager database
 210  *
 211  * RETURNS STD
 212  */
 213 BOOL WINAPI
 214 CloseServiceHandle( SC_HANDLE hSCObject )
 215 {
 216     TRACE("(%x)\n", hSCObject);
 217
 218     RegCloseKey(hSCObject);
 219
 220     return TRUE;
 221 }
 222
 223
 224 /******************************************************************************
 225  * OpenService32A [ADVAPI32.112]
 226  */
 227 SC_HANDLE WINAPI
 228 OpenServiceA( SC_HANDLE hSCManager, LPCSTR lpServiceName,
 229                 DWORD dwDesiredAccess )
 230 {
 231     LPWSTR lpServiceNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpServiceName);
 232     DWORD ret;
 233
 234     if(lpServiceName)
 235         TRACE("Request for service %s\n",lpServiceName);
 236     else
 237         return FALSE;
 238     ret = OpenServiceW( hSCManager, lpServiceNameW, dwDesiredAccess);
 239     HeapFree(GetProcessHeap(),0,lpServiceNameW);
 240     return ret;
 241 }
 242
 243
 244 /******************************************************************************
 245  * OpenService32W [ADVAPI32.113]
 246  * Opens a handle to an existing service
 247  *
 248  * PARAMS
 249  *   hSCManager      []
 250  *   lpServiceName   []
 251  *   dwDesiredAccess []
 252  *
 253  * RETURNS
 254  *    Success: Handle to the service
 255  *    Failure: NULL
 256  */
 257 SC_HANDLE WINAPI
 258 OpenServiceW(SC_HANDLE hSCManager, LPCWSTR lpServiceName,
 259                DWORD dwDesiredAccess)
 260 {
 261     const char *str = "System\\CurrentControlSet\\Services\\";
 262     WCHAR lpServiceKey[80]; /* FIXME: this should be dynamically allocated */
 263     HKEY hKey;
 264     long r;
 265
 266     TRACE("(%d,%p,%ld)\n",hSCManager, lpServiceName,
 267           dwDesiredAccess);
 268
 269     lstrcpyAtoW(lpServiceKey,str);
 270     lstrcatW(lpServiceKey,lpServiceName);
 271
 272     TRACE("Opening reg key %s\n", debugstr_w(lpServiceKey));
 273
 274     /* FIXME: dwDesiredAccess may need some processing */
 275     r = RegOpenKeyExW(hSCManager, lpServiceKey, 0, dwDesiredAccess, &hKey );
 276     if (r!=ERROR_SUCCESS)
 277         return 0;
 278
 279     TRACE("returning %x\n",hKey);
 280
 281     return hKey;
 282 }
 283
 284
 285 /******************************************************************************
 286  * CreateService32A [ADVAPI32.29]
 287  */
 288 SC_HANDLE WINAPI
 289 CreateServiceA( DWORD hSCManager, LPCSTR lpServiceName,
 290                   LPCSTR lpDisplayName, DWORD dwDesiredAccess,
 291                   DWORD dwServiceType, DWORD dwStartType,
 292                   DWORD dwErrorControl, LPCSTR lpBinaryPathName,
 293                   LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId,
 294                   LPCSTR lpDependencies, LPCSTR lpServiceStartName,
 295                   LPCSTR lpPassword )
 296 {
 297     FIXME("(%ld,%s,%s,...): stub\n",
 298           hSCManager, debugstr_a(lpServiceName), debugstr_a(lpDisplayName));
 299     return 1;
 300 }
 301
 302
 303 /******************************************************************************
 304  * DeleteService [ADVAPI32.31]
 305  *
 306  * PARAMS
 307  *    hService [I] Handle to service
 308  *
 309  * RETURNS STD
 310  *
 311  */
 312 BOOL WINAPI
 313 DeleteService( SC_HANDLE hService )
 314 {
 315     FIXME("(%d): stub\n",hService);
 316     return TRUE;
 317 }
 318
 319
 320 /******************************************************************************
 321  * StartService32A [ADVAPI32.195]
 322  *
 323  * NOTES
 324  *    How do we convert lpServiceArgVectors to use the 32W version?
 325  */
 326 BOOL WINAPI
 327 StartServiceA( SC_HANDLE hService, DWORD dwNumServiceArgs,
 328                  LPCSTR *lpServiceArgVectors )
 329 {
 330     FIXME("(%d,%ld,%p): stub\n",hService,dwNumServiceArgs,lpServiceArgVectors);
 331     return TRUE;
 332 }
 333
 334
 335 /******************************************************************************
 336  * StartService32W [ADVAPI32.198]
 337  * Starts a service
 338  *
 339  * PARAMS
 340  *   hService            [I] Handle of service
 341  *   dwNumServiceArgs    [I] Number of arguments
 342  *   lpServiceArgVectors [I] Address of array of argument string pointers
 343  *
 344  * RETURNS STD
 345  *
 346  */
 347 BOOL WINAPI
 348 StartServiceW( SC_HANDLE hService, DWORD dwNumServiceArgs,
 349                  LPCWSTR *lpServiceArgVectors )
 350 {
 351     FIXME("(%d,%ld,%p): stub\n",hService,dwNumServiceArgs,
 352           lpServiceArgVectors);
 353     return TRUE;
 354 }
 355
 356 /******************************************************************************
 357  * QueryServiceStatus [ADVAPI32.123]
 358  *
 359  * PARAMS
 360  *   hService        []
 361  *   lpservicestatus []
 362  *
 363  */
 364 BOOL WINAPI
 365 QueryServiceStatus( SC_HANDLE hService, LPSERVICE_STATUS lpservicestatus )
 366 {
 367     LONG r;
 368     DWORD type, val, size;
 369
 370     FIXME("(%x,%p) partial\n",hService,lpservicestatus);
 371
 372     /* read the service type from the registry */
 373     size = sizeof val;
 374     r = RegQueryValueExA(hService, "Type", NULL, &type, (LPBYTE)&val, &size);
 375     if(type!=REG_DWORD)
 376     {
 377         ERR("invalid Type\n");
 378         return FALSE;
 379     }
 380     lpservicestatus->dwServiceType = val;
 381
 382     /* FIXME: how are these determined or read from the registry? */
 383     lpservicestatus->dwCurrentState            = 0 /*SERVICE_STOPPED*/;
 384     lpservicestatus->dwControlsAccepted        = 0;
 385     lpservicestatus->dwWin32ExitCode           = NO_ERROR;
 386     lpservicestatus->dwServiceSpecificExitCode = 0;
 387     lpservicestatus->dwCheckPoint              = 0;
 388     lpservicestatus->dwWaitHint                = 0;
 389
 390     return TRUE;
 391 }
 392