win32/advapi.c

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