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