win32/advapi.c

   1 /*
   2  * Win32 advapi functions
   3  *
   4  * Copyright 1995 Sven Verdoolaege
   5  */
   6
   7 #include <stdio.h>
   8 #include <unistd.h>
   9 #include <time.h>
  10 #include "windows.h"
  11 #include "winerror.h"
  12 #include "shell.h"
  13 #include "heap.h"
  14 #include "debug.h"
  15
  16 /***********************************************************************
  17  *           StartServiceCtrlDispatcherA   [ADVAPI32.196]
  18  */
  19 BOOL32 WINAPI StartServiceCtrlDispatcher32A(LPSERVICE_TABLE_ENTRY32A servent)
  20 {
  21         FIXME(advapi,"(%p '%s'): STUB.\n",servent,servent->lpServiceName);
  22         return TRUE;
  23 }
  24
  25 /***********************************************************************
  26  *           StartServiceCtrlDispatcherW   [ADVAPI32.197]
  27  */
  28 BOOL32 WINAPI StartServiceCtrlDispatcher32W(LPSERVICE_TABLE_ENTRY32W servent)
  29 {
  30         char    buffer[200];
  31
  32         lstrcpynWtoA(buffer,servent->lpServiceName,200);
  33         FIXME(advapi,"(%p '%s'): STUB.\n",servent,buffer);
  34         return TRUE;
  35 }
  36
  37
  38 /******************************************************************************
  39  * OpenProcessToken [ADVAPI32.109]
  40  * Opens the access token associated with a process
  41  *
  42  * PARAMS
  43  *    ProcessHandle [I] Handle to process
  44  *    DesiredAccess [I] Desired access to process
  45  *    TokenHandle   [O] Pointer to handle of open access token
  46  *
  47  * RETURNS STD
  48  */
  49 BOOL32 WINAPI OpenProcessToken( HANDLE32 ProcessHandle, DWORD DesiredAccess,
  50                                 HANDLE32 *TokenHandle )
  51 {
  52     FIXME(advapi,"(%08x,%08lx,%p): stub\n",ProcessHandle,DesiredAccess,
  53           TokenHandle);
  54     return TRUE;
  55 }
  56
  57
  58 /***********************************************************************
  59  *           OpenThreadToken            [ADVAPI32.114]
  60  */
  61 BOOL32 WINAPI OpenThreadToken( HANDLE32 thread,DWORD desiredaccess,
  62                                BOOL32 openasself,HANDLE32 *thandle )
  63 {
  64         FIXME(advapi,"(%08x,%08lx,%d,%p): stub!\n",
  65               thread,desiredaccess,openasself,thandle);
  66         return TRUE;
  67 }
  68
  69
  70 /******************************************************************************
  71  * LookupPrivilegeValue32A                                        [ADVAPI32.92]
  72  */
  73 BOOL32 WINAPI LookupPrivilegeValue32A( LPCSTR lpSystemName,
  74                                        LPCSTR lpName, LPVOID lpLuid)
  75 {
  76     LPWSTR lpSystemNameW = HEAP_strdupAtoW(GetProcessHeap(), 0, lpSystemName);
  77     LPWSTR lpNameW = HEAP_strdupAtoW(GetProcessHeap(), 0, lpName);
  78     BOOL32 ret = LookupPrivilegeValue32W( lpSystemNameW, lpNameW, lpLuid);
  79     HeapFree(GetProcessHeap(), 0, lpNameW);
  80     HeapFree(GetProcessHeap(), 0, lpSystemNameW);
  81     return ret;
  82 }
  83
  84
  85 /******************************************************************************
  86  * LookupPrivilegeValue32W                                        [ADVAPI32.93]
  87  * Retrieves LUID used on a system to represent the privilege name.
  88  *
  89  * NOTES
  90  *    lpLuid should be PLUID
  91  *
  92  * PARAMS
  93  *    lpSystemName [I] Address of string specifying the system
  94  *    lpName       [I] Address of string specifying the privilege
  95  *    lpLuid       [I] Address of locally unique identifier
  96  *
  97  * RETURNS STD
  98  */
  99 BOOL32 WINAPI LookupPrivilegeValue32W( LPCWSTR lpSystemName,
 100                                        LPCWSTR lpName, LPVOID lpLuid )
 101 {
 102     FIXME(advapi,"(%s,%s,%p): stub\n",debugstr_w(lpSystemName),
 103                   debugstr_w(lpName), lpLuid);
 104     return TRUE;
 105 }
 106
 107
 108 /***********************************************************************
 109  *           AdjustTokenPrivileges   [ADVAPI32.10]
 110  */
 111 BOOL32 WINAPI AdjustTokenPrivileges(HANDLE32 TokenHandle,BOOL32 DisableAllPrivileges,
 112         LPVOID NewState,DWORD BufferLength,LPVOID PreviousState,
 113         LPDWORD ReturnLength )
 114 {
 115         return TRUE;
 116 }
 117
 118 /***********************************************************************
 119  *           GetTokenInformation        [ADVAPI32.66]
 120  */
 121 BOOL32 WINAPI GetTokenInformation(
 122         HANDLE32 token,/*TOKEN_INFORMATION_CLASS*/ DWORD tokeninfoclass,LPVOID tokeninfo,
 123         DWORD tokeninfolength,LPDWORD retlen
 124 ) {
 125         FIXME(advapi,"(%08x,%ld,%p,%ld,%p): stub\n",
 126               token,tokeninfoclass,tokeninfo,tokeninfolength,retlen);
 127         return TRUE;
 128 }
 129
 130
 131 /******************************************************************************
 132  * OpenSCManager32A [ADVAPI32.110]
 133  */
 134 HANDLE32 WINAPI OpenSCManager32A( LPCSTR lpMachineName, LPCSTR lpDatabaseName,
 135                                   DWORD dwDesiredAccess )
 136 {
 137     LPWSTR lpMachineNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpMachineName);
 138     LPWSTR lpDatabaseNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpDatabaseName);
 139     DWORD ret = OpenSCManager32W(lpMachineNameW,lpDatabaseNameW,
 140                                  dwDesiredAccess);
 141     HeapFree(GetProcessHeap(),0,lpDatabaseNameW);
 142     HeapFree(GetProcessHeap(),0,lpMachineNameW);
 143     return ret;
 144 }
 145
 146
 147 /******************************************************************************
 148  * OpenSCManager32W [ADVAPI32.111]
 149  * Establishes a connection to the service control manager and opens database
 150  *
 151  * NOTES
 152  *    This should return a SC_HANDLE
 153  *
 154  * PARAMS
 155  *    lpMachineName   [I] Pointer to machine name string
 156  *    lpDatabaseName  [I] Pointer to database name string
 157  *    dwDesiredAccess [I] Type of access
 158  *
 159  * RETURNS
 160  *    Success: Handle to service control manager database
 161  *    Failure: NULL
 162  */
 163 HANDLE32 WINAPI OpenSCManager32W( LPCWSTR lpMachineName, LPCWSTR lpDatabaseName,
 164                                   DWORD dwDesiredAccess )
 165 {
 166     FIXME(advapi,"(%s,%s,%08lx): stub\n", debugstr_w(lpMachineName),
 167           debugstr_w(lpDatabaseName), dwDesiredAccess);
 168     return 1;
 169 }
 170
 171
 172 BOOL32 WINAPI AllocateLocallyUniqueId(LPLUID lpluid) {
 173         lpluid->LowPart = time(NULL);
 174         lpluid->HighPart = 0;
 175         return TRUE;
 176 }
 177
 178
 179 /******************************************************************************
 180  * ControlService [ADVAPI32.23]
 181  * Sends a control code to a Win32-based service.
 182  *
 183  * NOTES
 184  *    hService should be SC_HANDLE
 185  *
 186  * RETURNS STD
 187  */
 188 BOOL32 WINAPI ControlService( HANDLE32 hService, DWORD dwControl,
 189                               LPSERVICE_STATUS lpServiceStatus )
 190 {
 191     FIXME(advapi, "(%d,%ld,%p): stub\n",hService,dwControl,lpServiceStatus);
 192     return TRUE;
 193 }
 194
 195
 196 /******************************************************************************
 197  * CloseServiceHandle [ADVAPI32.22]
 198  * Close handle to service or service control manager
 199  *
 200  * PARAMS
 201  *    hSCObject [I] Handle to service or service control manager database
 202  *
 203  * NOTES
 204  *    hSCObject should be SC_HANDLE
 205  *
 206  * RETURNS STD
 207  */
 208 BOOL32 WINAPI CloseServiceHandle( HANDLE32 hSCObject )
 209 {
 210     FIXME(advapi, "(%d): stub\n", hSCObject);
 211     return TRUE;
 212 }
 213
 214
 215 /******************************************************************************
 216  * OpenService32A [ADVAPI32.112]
 217  */
 218 HANDLE32 WINAPI OpenService32A( HANDLE32 hSCManager, LPCSTR lpServiceName,
 219                                 DWORD dwDesiredAccess )
 220 {
 221     LPWSTR lpServiceNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpServiceName);
 222     DWORD ret = OpenService32W( 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  * NOTES
 233  *    The return value should be SC_HANDLE
 234  *    hSCManager should be SC_HANDLE
 235  *
 236  * RETURNS
 237  *    Success: Handle to the service
 238  *    Failure: NULL
 239  */
 240 HANDLE32 WINAPI OpenService32W( HANDLE32 hSCManager, LPCWSTR lpServiceName,
 241                                 DWORD dwDesiredAccess )
 242 {
 243     FIXME(advapi, "(%d,%p,%ld): stub\n",hSCManager, lpServiceName,
 244           dwDesiredAccess);
 245     return 1;
 246 }
 247
 248
 249 /******************************************************************************
 250  * CreateServiceA [ADVAPI32.28]
 251  */
 252 DWORD WINAPI CreateServiceA( DWORD hSCManager, LPCSTR lpServiceName,
 253                              LPCSTR lpDisplayName, DWORD dwDesiredAccess,
 254                              DWORD dwServiceType, DWORD dwStartType,
 255                              DWORD dwErrorControl, LPCSTR lpBinaryPathName,
 256                              LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId,
 257                              LPCSTR lpDependencies, LPCSTR lpServiceStartName,
 258                              LPCSTR lpPassword )
 259 {
 260     FIXME(advapi, "(%ld,%s,%s,...): stub\n",
 261           hSCManager, debugstr_a(lpServiceName), debugstr_a(lpDisplayName));
 262     return 1;
 263 }
 264
 265
 266 /******************************************************************************
 267  * DeleteService [ADVAPI32.31]
 268  *
 269  * PARAMS
 270  *    hService [I] Handle to service
 271  *
 272  * RETURNS STD
 273  *
 274  * NOTES
 275  *    hService should be SC_HANDLE
 276  */
 277 BOOL32 WINAPI DeleteService( HANDLE32 hService )
 278 {
 279     FIXME(advapi, "(%d): stub\n",hService);
 280     return TRUE;
 281 }
 282
 283
 284 /******************************************************************************
 285  * StartService32A [ADVAPI32.195]
 286  *
 287  * NOTES
 288  *    How do we convert lpServiceArgVectors to use the 32W version?
 289  */
 290 BOOL32 WINAPI StartService32A( HANDLE32 hService, DWORD dwNumServiceArgs,
 291                                LPCSTR *lpServiceArgVectors )
 292 {
 293     FIXME(advapi, "(%d,%ld,%p): stub\n",hService,dwNumServiceArgs,lpServiceArgVectors);
 294     return TRUE;
 295 }
 296
 297
 298 /******************************************************************************
 299  * StartService32W [ADVAPI32.198]
 300  * Starts a service
 301  *
 302  * PARAMS
 303  *    hService            [I] Handle of service
 304  *    dwNumServiceArgs    [I] Number of arguments
 305  *    lpServiceArgVectors [I] Address of array of argument string pointers
 306  *
 307  * RETURNS STD
 308  *
 309  * NOTES
 310  *    hService should be SC_HANDLE
 311  */
 312 BOOL32 WINAPI StartService32W( HANDLE32 hService, DWORD dwNumServiceArgs,
 313                                LPCWSTR *lpServiceArgVectors )
 314 {
 315     FIXME(advapi, "(%d,%ld,%p): stub\n",hService,dwNumServiceArgs,
 316           lpServiceArgVectors);
 317     return TRUE;
 318 }
 319
 320
 321 /******************************************************************************
 322  * DeregisterEventSource [ADVAPI32.32]
 323  * Closes a handle to the specified event log
 324  *
 325  * PARAMS
 326  *    hEventLog [I] Handle to event log
 327  *
 328  * RETURNS STD
 329  */
 330 BOOL32 WINAPI DeregisterEventSource( HANDLE32 hEventLog )
 331 {
 332     FIXME(advapi, "(%d): stub\n",hEventLog);
 333     return TRUE;
 334 }
 335
 336
 337 /******************************************************************************
 338  * RegisterEventSource32A [ADVAPI32.174]
 339  */
 340 HANDLE32 WINAPI RegisterEventSource32A( LPCSTR lpUNCServerName,
 341                                         LPCSTR lpSourceName )
 342 {
 343     LPWSTR lpUNCServerNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpUNCServerName);
 344     LPWSTR lpSourceNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpSourceName);
 345     HANDLE32 ret = RegisterEventSource32W(lpUNCServerNameW,lpSourceNameW);
 346     HeapFree(GetProcessHeap(),0,lpSourceNameW);
 347     HeapFree(GetProcessHeap(),0,lpUNCServerNameW);
 348     return ret;
 349 }
 350
 351
 352 /******************************************************************************
 353  * RegisterEventSource32W [ADVAPI32.175]
 354  * Returns a registered handle to an event log
 355  *
 356  * PARAMS
 357  *    lpUNCServerName [I] Server name for source
 358  *    lpSourceName    [I] Source name for registered handle
 359  *
 360  * RETURNS
 361  *    Success: Handle
 362  *    Failure: NULL
 363  */
 364 HANDLE32 WINAPI RegisterEventSource32W( LPCWSTR lpUNCServerName,
 365                                         LPCWSTR lpSourceName )
 366 {
 367     FIXME(advapi, "(%s,%s): stub\n", debugstr_w(lpUNCServerName),
 368           debugstr_w(lpSourceName));
 369     return 1;
 370 }
 371