git.oblomov.eu Git - wine/blob - dlls/advapi32/service.c

   1 /*
   2  * Win32 advapi functions
   3  *
   4  * Copyright 1995 Sven Verdoolaege
   5  */
   6
   7 #include <time.h>
   8 #include "wintypes.h"
   9 #include "winreg.h"
  10 #include "winerror.h"
  11 #include "heap.h"
  12 #include "debug.h"
  13
  14 /* FIXME: Where do these belong? */
  15 typedef DWORD   SERVICE_STATUS_HANDLE;
  16 typedef VOID (WINAPI *LPHANDLER_FUNCTION)( DWORD dwControl);
  17
  18
  19 /******************************************************************************
  20  * EnumServicesStatus32A [ADVAPI32.38]
  21  */
  22 BOOL32 WINAPI
  23 EnumServicesStatus32A( HANDLE32 hSCManager, DWORD dwServiceType,
  24                        DWORD dwServiceState, LPVOID lpServices,
  25                        DWORD cbBufSize, LPDWORD pcbBytesNeeded,
  26                        LPDWORD lpServicesReturned, LPDWORD lpResumeHandle )
  27 {       FIXME (advapi,"%x type=%lx state=%lx %p %lx %p %p %p\n", hSCManager,
  28                 dwServiceType, dwServiceState, lpServices, cbBufSize,
  29                 pcbBytesNeeded, lpServicesReturned,  lpResumeHandle);
  30         SetLastError (ERROR_ACCESS_DENIED);
  31         return 0;
  32 }
  33
  34 /******************************************************************************
  35  * StartServiceCtrlDispatcher32A [ADVAPI32.196]
  36  */
  37 BOOL32 WINAPI
  38 StartServiceCtrlDispatcher32A( LPSERVICE_TABLE_ENTRY32A servent )
  39 {       LPSERVICE_TABLE_ENTRY32A ptr = servent;
  40
  41         while (ptr->lpServiceName)
  42         { FIXME(advapi,"%s at %p\n", ptr->lpServiceName, ptr);
  43           ptr++;
  44         }
  45         return TRUE;
  46 }
  47
  48 /******************************************************************************
  49  * StartServiceCtrlDispatcher32W [ADVAPI32.197]
  50  *
  51  * PARAMS
  52  *   servent []
  53  */
  54 BOOL32 WINAPI
  55 StartServiceCtrlDispatcher32W( LPSERVICE_TABLE_ENTRY32W servent )
  56 {       LPSERVICE_TABLE_ENTRY32W ptr = servent;
  57         LPSERVICE_MAIN_FUNCTION32W fpMain;
  58
  59         while (ptr->lpServiceName)
  60         { FIXME(advapi,"%s at %p): STUB.\n", debugstr_w(ptr->lpServiceName),ptr);
  61           fpMain = ptr->lpServiceProc;
  62           fpMain(0,NULL);       /* try to start the service */
  63           ptr++;
  64         }
  65         return TRUE;
  66 }
  67
  68 /******************************************************************************
  69  * RegisterServiceCtrlHandlerA [ADVAPI32.176]
  70  */
  71 SERVICE_STATUS_HANDLE WINAPI
  72 RegisterServiceCtrlHandlerA( LPSTR lpServiceName,
  73                              LPHANDLER_FUNCTION lpfHandler )
  74 {       FIXME(advapi,"%s %p\n", lpServiceName, lpfHandler);
  75         return 0xcacacafe;
  76 }
  77
  78 /******************************************************************************
  79  * RegisterServiceCtrlHandlerW [ADVAPI32.177]
  80  *
  81  * PARAMS
  82  *   lpServiceName []
  83  *   lpfHandler    []
  84  */
  85 SERVICE_STATUS_HANDLE WINAPI
  86 RegisterServiceCtrlHandlerW( LPWSTR lpServiceName,
  87                              LPHANDLER_FUNCTION lpfHandler )
  88 {       FIXME(advapi,"%s %p\n", debugstr_w(lpServiceName), lpfHandler);
  89         return 0xcacacafe;
  90 }
  91
  92 /******************************************************************************
  93  * SetServiceStatus [ADVAPI32.192]
  94  *
  95  * PARAMS
  96  *   hService []
  97  *   lpStatus []
  98  */
  99 BOOL32 WINAPI
 100 SetServiceStatus( SERVICE_STATUS_HANDLE hService, LPSERVICE_STATUS lpStatus )
 101 {       FIXME(advapi,"%lx %p\n",hService, lpStatus);
 102         TRACE(advapi,"\tType:%lx\n",lpStatus->dwServiceType);
 103         TRACE(advapi,"\tState:%lx\n",lpStatus->dwCurrentState);
 104         TRACE(advapi,"\tControlAccepted:%lx\n",lpStatus->dwControlsAccepted);
 105         TRACE(advapi,"\tExitCode:%lx\n",lpStatus->dwWin32ExitCode);
 106         TRACE(advapi,"\tServiceExitCode:%lx\n",lpStatus->dwServiceSpecificExitCode);
 107         TRACE(advapi,"\tCheckPoint:%lx\n",lpStatus->dwCheckPoint);
 108         TRACE(advapi,"\tWaitHint:%lx\n",lpStatus->dwWaitHint);
 109         return TRUE;
 110 }
 111
 112 /******************************************************************************
 113  * OpenSCManager32A [ADVAPI32.110]
 114  */
 115 HANDLE32 WINAPI
 116 OpenSCManager32A( LPCSTR lpMachineName, LPCSTR lpDatabaseName,
 117                   DWORD dwDesiredAccess )
 118 {
 119     LPWSTR lpMachineNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpMachineName);
 120     LPWSTR lpDatabaseNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpDatabaseName);
 121     DWORD ret = OpenSCManager32W(lpMachineNameW,lpDatabaseNameW,
 122                                  dwDesiredAccess);
 123     HeapFree(GetProcessHeap(),0,lpDatabaseNameW);
 124     HeapFree(GetProcessHeap(),0,lpMachineNameW);
 125     return ret;
 126 }
 127
 128 /******************************************************************************
 129  * OpenSCManager32W [ADVAPI32.111]
 130  * Establishes a connection to the service control manager and opens database
 131  *
 132  * NOTES
 133  *   This should return a SC_HANDLE
 134  *
 135  * PARAMS
 136  *   lpMachineName   [I] Pointer to machine name string
 137  *   lpDatabaseName  [I] Pointer to database name string
 138  *   dwDesiredAccess [I] Type of access
 139  *
 140  * RETURNS
 141  *   Success: Handle to service control manager database
 142  *   Failure: NULL
 143  */
 144 HANDLE32 WINAPI
 145 OpenSCManager32W( LPCWSTR lpMachineName, LPCWSTR lpDatabaseName,
 146                   DWORD dwDesiredAccess )
 147 {
 148     FIXME(advapi,"(%s,%s,0x%08lx): stub\n", debugstr_w(lpMachineName),
 149           debugstr_w(lpDatabaseName), dwDesiredAccess);
 150     return 1;
 151 }
 152
 153
 154 /******************************************************************************
 155  * AllocateLocallyUniqueId [ADVAPI32.12]
 156  *
 157  * PARAMS
 158  *   lpluid []
 159  */
 160 BOOL32 WINAPI
 161 AllocateLocallyUniqueId( PLUID lpluid )
 162 {
 163         lpluid->LowPart = time(NULL);
 164         lpluid->HighPart = 0;
 165         return TRUE;
 166 }
 167
 168
 169 /******************************************************************************
 170  * ControlService [ADVAPI32.23]
 171  * Sends a control code to a Win32-based service.
 172  *
 173  * PARAMS
 174  *   hService        []
 175  *   dwControl       []
 176  *   lpServiceStatus []
 177  *
 178  * NOTES
 179  *    hService should be SC_HANDLE
 180  *
 181  * RETURNS STD
 182  */
 183 BOOL32 WINAPI
 184 ControlService( HANDLE32 hService, DWORD dwControl,
 185                 LPSERVICE_STATUS lpServiceStatus )
 186 {
 187     FIXME(advapi, "(%d,%ld,%p): stub\n",hService,dwControl,lpServiceStatus);
 188     return TRUE;
 189 }
 190
 191
 192 /******************************************************************************
 193  * CloseServiceHandle [ADVAPI32.22]
 194  * Close handle to service or service control manager
 195  *
 196  * PARAMS
 197  *   hSCObject [I] Handle to service or service control manager database
 198  *
 199  * NOTES
 200  *   hSCObject should be SC_HANDLE
 201  *
 202  * RETURNS STD
 203  */
 204 BOOL32 WINAPI
 205 CloseServiceHandle( HANDLE32 hSCObject )
 206 {
 207     FIXME(advapi, "(%d): stub\n", hSCObject);
 208     return TRUE;
 209 }
 210
 211
 212 /******************************************************************************
 213  * OpenService32A [ADVAPI32.112]
 214  */
 215 HANDLE32 WINAPI
 216 OpenService32A( HANDLE32 hSCManager, LPCSTR lpServiceName,
 217                 DWORD dwDesiredAccess )
 218 {
 219     LPWSTR lpServiceNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpServiceName);
 220     DWORD ret = OpenService32W( hSCManager, lpServiceNameW, dwDesiredAccess);
 221     HeapFree(GetProcessHeap(),0,lpServiceNameW);
 222     return ret;
 223 }
 224
 225
 226 /******************************************************************************
 227  * OpenService32W [ADVAPI32.113]
 228  * Opens a handle to an existing service
 229  *
 230  * PARAMS
 231  *   hSCManager      []
 232  *   lpServiceName   []
 233  *   dwDesiredAccess []
 234  *
 235  * NOTES
 236  *    The return value should be SC_HANDLE
 237  *    hSCManager should be SC_HANDLE
 238  *
 239  * RETURNS
 240  *    Success: Handle to the service
 241  *    Failure: NULL
 242  */
 243 HANDLE32 WINAPI
 244 OpenService32W(HANDLE32 hSCManager, LPCWSTR lpServiceName,
 245                DWORD dwDesiredAccess)
 246 {
 247     FIXME(advapi, "(%d,%p,%ld): stub\n",hSCManager, lpServiceName,
 248           dwDesiredAccess);
 249     return 1;
 250 }
 251
 252
 253 /******************************************************************************
 254  * CreateService32A [ADVAPI32.29]
 255  */
 256 DWORD WINAPI
 257 CreateService32A( DWORD hSCManager, LPCSTR lpServiceName,
 258                   LPCSTR lpDisplayName, DWORD dwDesiredAccess,
 259                   DWORD dwServiceType, DWORD dwStartType,
 260                   DWORD dwErrorControl, LPCSTR lpBinaryPathName,
 261                   LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId,
 262                   LPCSTR lpDependencies, LPCSTR lpServiceStartName,
 263                   LPCSTR lpPassword )
 264 {
 265     FIXME(advapi, "(%ld,%s,%s,...): stub\n",
 266           hSCManager, debugstr_a(lpServiceName), debugstr_a(lpDisplayName));
 267     return 1;
 268 }
 269
 270
 271 /******************************************************************************
 272  * DeleteService [ADVAPI32.31]
 273  *
 274  * PARAMS
 275  *    hService [I] Handle to service
 276  *
 277  * RETURNS STD
 278  *
 279  * NOTES
 280  *    hService should be SC_HANDLE
 281  */
 282 BOOL32 WINAPI
 283 DeleteService( HANDLE32 hService )
 284 {
 285     FIXME(advapi, "(%d): stub\n",hService);
 286     return TRUE;
 287 }
 288
 289
 290 /******************************************************************************
 291  * StartService32A [ADVAPI32.195]
 292  *
 293  * NOTES
 294  *    How do we convert lpServiceArgVectors to use the 32W version?
 295  */
 296 BOOL32 WINAPI
 297 StartService32A( HANDLE32 hService, DWORD dwNumServiceArgs,
 298                  LPCSTR *lpServiceArgVectors )
 299 {
 300     FIXME(advapi, "(%d,%ld,%p): stub\n",hService,dwNumServiceArgs,lpServiceArgVectors);
 301     return TRUE;
 302 }
 303
 304
 305 /******************************************************************************
 306  * StartService32W [ADVAPI32.198]
 307  * Starts a service
 308  *
 309  * PARAMS
 310  *   hService            [I] Handle of service
 311  *   dwNumServiceArgs    [I] Number of arguments
 312  *   lpServiceArgVectors [I] Address of array of argument string pointers
 313  *
 314  * RETURNS STD
 315  *
 316  * NOTES
 317  *   hService should be SC_HANDLE
 318  */
 319 BOOL32 WINAPI
 320 StartService32W( HANDLE32 hService, DWORD dwNumServiceArgs,
 321                  LPCWSTR *lpServiceArgVectors )
 322 {
 323     FIXME(advapi, "(%d,%ld,%p): stub\n",hService,dwNumServiceArgs,
 324           lpServiceArgVectors);
 325     return TRUE;
 326 }
 327
 328 /******************************************************************************
 329  * QueryServiceStatus [ADVAPI32.123]
 330  *
 331  * PARAMS
 332  *   hService        []
 333  *   lpservicestatus []
 334  *
 335  * FIXME
 336  *   hService should be SC_HANDLE
 337  *   lpservicestatus should be LPSERVICE_STATUS
 338  */
 339 BOOL32 WINAPI
 340 QueryServiceStatus( HANDLE32 hService, LPVOID lpservicestatus )
 341 {
 342         FIXME(advapi,"(%d,%p),stub!\n",hService,lpservicestatus);
 343         return TRUE;
 344 }
 345