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