| /* |
| * Win32 advapi functions |
| * |
| * Copyright 1995 Sven Verdoolaege |
| */ |
| |
| #include <unistd.h> |
| #include <time.h> |
| #include "windows.h" |
| #include "winerror.h" |
| #include "shell.h" |
| #include "heap.h" |
| #include "debug.h" |
| |
| /*********************************************************************** |
| * StartServiceCtrlDispatcherA [ADVAPI32.196] |
| */ |
| BOOL32 WINAPI StartServiceCtrlDispatcher32A(LPSERVICE_TABLE_ENTRY32A servent) |
| { |
| FIXME(advapi,"(%p '%s'): STUB.\n",servent,servent->lpServiceName); |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * StartServiceCtrlDispatcherW [ADVAPI32.197] |
| */ |
| BOOL32 WINAPI StartServiceCtrlDispatcher32W(LPSERVICE_TABLE_ENTRY32W servent) |
| { |
| char buffer[200]; |
| |
| lstrcpynWtoA(buffer,servent->lpServiceName,200); |
| FIXME(advapi,"(%p '%s'): STUB.\n",servent,buffer); |
| return TRUE; |
| } |
| |
| |
| /****************************************************************************** |
| * OpenProcessToken [ADVAPI32.109] |
| * Opens the access token associated with a process |
| * |
| * PARAMS |
| * ProcessHandle [I] Handle to process |
| * DesiredAccess [I] Desired access to process |
| * TokenHandle [O] Pointer to handle of open access token |
| * |
| * RETURNS STD |
| */ |
| BOOL32 WINAPI OpenProcessToken( HANDLE32 ProcessHandle, DWORD DesiredAccess, |
| HANDLE32 *TokenHandle ) |
| { |
| FIXME(advapi,"(%08x,%08lx,%p): stub\n",ProcessHandle,DesiredAccess, |
| TokenHandle); |
| return TRUE; |
| } |
| |
| |
| /*********************************************************************** |
| * OpenThreadToken [ADVAPI32.114] |
| */ |
| BOOL32 WINAPI OpenThreadToken( HANDLE32 thread,DWORD desiredaccess, |
| BOOL32 openasself,HANDLE32 *thandle ) |
| { |
| FIXME(advapi,"(%08x,%08lx,%d,%p): stub!\n", |
| thread,desiredaccess,openasself,thandle); |
| return TRUE; |
| } |
| |
| |
| /****************************************************************************** |
| * LookupPrivilegeValue32A [ADVAPI32.92] |
| */ |
| BOOL32 WINAPI LookupPrivilegeValue32A( LPCSTR lpSystemName, |
| LPCSTR lpName, LPVOID lpLuid) |
| { |
| LPWSTR lpSystemNameW = HEAP_strdupAtoW(GetProcessHeap(), 0, lpSystemName); |
| LPWSTR lpNameW = HEAP_strdupAtoW(GetProcessHeap(), 0, lpName); |
| BOOL32 ret = LookupPrivilegeValue32W( lpSystemNameW, lpNameW, lpLuid); |
| HeapFree(GetProcessHeap(), 0, lpNameW); |
| HeapFree(GetProcessHeap(), 0, lpSystemNameW); |
| return ret; |
| } |
| |
| |
| /****************************************************************************** |
| * LookupPrivilegeValue32W [ADVAPI32.93] |
| * Retrieves LUID used on a system to represent the privilege name. |
| * |
| * NOTES |
| * lpLuid should be PLUID |
| * |
| * PARAMS |
| * lpSystemName [I] Address of string specifying the system |
| * lpName [I] Address of string specifying the privilege |
| * lpLuid [I] Address of locally unique identifier |
| * |
| * RETURNS STD |
| */ |
| BOOL32 WINAPI LookupPrivilegeValue32W( LPCWSTR lpSystemName, |
| LPCWSTR lpName, LPVOID lpLuid ) |
| { |
| FIXME(advapi,"(%s,%s,%p): stub\n",debugstr_w(lpSystemName), |
| debugstr_w(lpName), lpLuid); |
| return TRUE; |
| } |
| |
| |
| /*********************************************************************** |
| * AdjustTokenPrivileges [ADVAPI32.10] |
| */ |
| BOOL32 WINAPI AdjustTokenPrivileges(HANDLE32 TokenHandle,BOOL32 DisableAllPrivileges, |
| LPVOID NewState,DWORD BufferLength,LPVOID PreviousState, |
| LPDWORD ReturnLength ) |
| { |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * GetTokenInformation [ADVAPI32.66] |
| */ |
| BOOL32 WINAPI GetTokenInformation( |
| HANDLE32 token,/*TOKEN_INFORMATION_CLASS*/ DWORD tokeninfoclass,LPVOID tokeninfo, |
| DWORD tokeninfolength,LPDWORD retlen |
| ) { |
| FIXME(advapi,"(%08x,%ld,%p,%ld,%p): stub\n", |
| token,tokeninfoclass,tokeninfo,tokeninfolength,retlen); |
| return TRUE; |
| } |
| |
| |
| /****************************************************************************** |
| * OpenSCManager32A [ADVAPI32.110] |
| */ |
| HANDLE32 WINAPI OpenSCManager32A( LPCSTR lpMachineName, LPCSTR lpDatabaseName, |
| DWORD dwDesiredAccess ) |
| { |
| LPWSTR lpMachineNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpMachineName); |
| LPWSTR lpDatabaseNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpDatabaseName); |
| DWORD ret = OpenSCManager32W(lpMachineNameW,lpDatabaseNameW, |
| dwDesiredAccess); |
| HeapFree(GetProcessHeap(),0,lpDatabaseNameW); |
| HeapFree(GetProcessHeap(),0,lpMachineNameW); |
| return ret; |
| } |
| |
| |
| /****************************************************************************** |
| * OpenSCManager32W [ADVAPI32.111] |
| * Establishes a connection to the service control manager and opens database |
| * |
| * NOTES |
| * This should return a SC_HANDLE |
| * |
| * PARAMS |
| * lpMachineName [I] Pointer to machine name string |
| * lpDatabaseName [I] Pointer to database name string |
| * dwDesiredAccess [I] Type of access |
| * |
| * RETURNS |
| * Success: Handle to service control manager database |
| * Failure: NULL |
| */ |
| HANDLE32 WINAPI OpenSCManager32W( LPCWSTR lpMachineName, LPCWSTR lpDatabaseName, |
| DWORD dwDesiredAccess ) |
| { |
| FIXME(advapi,"(%s,%s,%08lx): stub\n", debugstr_w(lpMachineName), |
| debugstr_w(lpDatabaseName), dwDesiredAccess); |
| return 1; |
| } |
| |
| |
| BOOL32 WINAPI AllocateLocallyUniqueId(LPLUID lpluid) { |
| lpluid->LowPart = time(NULL); |
| lpluid->HighPart = 0; |
| return TRUE; |
| } |
| |
| |
| /****************************************************************************** |
| * ControlService [ADVAPI32.23] |
| * Sends a control code to a Win32-based service. |
| * |
| * NOTES |
| * hService should be SC_HANDLE |
| * |
| * RETURNS STD |
| */ |
| BOOL32 WINAPI ControlService( HANDLE32 hService, DWORD dwControl, |
| LPSERVICE_STATUS lpServiceStatus ) |
| { |
| FIXME(advapi, "(%d,%ld,%p): stub\n",hService,dwControl,lpServiceStatus); |
| return TRUE; |
| } |
| |
| |
| /****************************************************************************** |
| * CloseServiceHandle [ADVAPI32.22] |
| * Close handle to service or service control manager |
| * |
| * PARAMS |
| * hSCObject [I] Handle to service or service control manager database |
| * |
| * NOTES |
| * hSCObject should be SC_HANDLE |
| * |
| * RETURNS STD |
| */ |
| BOOL32 WINAPI CloseServiceHandle( HANDLE32 hSCObject ) |
| { |
| FIXME(advapi, "(%d): stub\n", hSCObject); |
| return TRUE; |
| } |
| |
| |
| /****************************************************************************** |
| * OpenService32A [ADVAPI32.112] |
| */ |
| HANDLE32 WINAPI OpenService32A( HANDLE32 hSCManager, LPCSTR lpServiceName, |
| DWORD dwDesiredAccess ) |
| { |
| LPWSTR lpServiceNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpServiceName); |
| DWORD ret = OpenService32W( hSCManager, lpServiceNameW, dwDesiredAccess); |
| HeapFree(GetProcessHeap(),0,lpServiceNameW); |
| return ret; |
| } |
| |
| |
| /****************************************************************************** |
| * OpenService32W [ADVAPI32.113] |
| * Opens a handle to an existing service |
| * |
| * NOTES |
| * The return value should be SC_HANDLE |
| * hSCManager should be SC_HANDLE |
| * |
| * RETURNS |
| * Success: Handle to the service |
| * Failure: NULL |
| */ |
| HANDLE32 WINAPI OpenService32W( HANDLE32 hSCManager, LPCWSTR lpServiceName, |
| DWORD dwDesiredAccess ) |
| { |
| FIXME(advapi, "(%d,%p,%ld): stub\n",hSCManager, lpServiceName, |
| dwDesiredAccess); |
| return 1; |
| } |
| |
| |
| /****************************************************************************** |
| * CreateServiceA [ADVAPI32.28] |
| */ |
| DWORD WINAPI CreateServiceA( DWORD hSCManager, LPCSTR lpServiceName, |
| LPCSTR lpDisplayName, DWORD dwDesiredAccess, |
| DWORD dwServiceType, DWORD dwStartType, |
| DWORD dwErrorControl, LPCSTR lpBinaryPathName, |
| LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId, |
| LPCSTR lpDependencies, LPCSTR lpServiceStartName, |
| LPCSTR lpPassword ) |
| { |
| FIXME(advapi, "(%ld,%s,%s,...): stub\n", |
| hSCManager, debugstr_a(lpServiceName), debugstr_a(lpDisplayName)); |
| return 1; |
| } |
| |
| |
| /****************************************************************************** |
| * DeleteService [ADVAPI32.31] |
| * |
| * PARAMS |
| * hService [I] Handle to service |
| * |
| * RETURNS STD |
| * |
| * NOTES |
| * hService should be SC_HANDLE |
| */ |
| BOOL32 WINAPI DeleteService( HANDLE32 hService ) |
| { |
| FIXME(advapi, "(%d): stub\n",hService); |
| return TRUE; |
| } |
| |
| |
| /****************************************************************************** |
| * StartService32A [ADVAPI32.195] |
| * |
| * NOTES |
| * How do we convert lpServiceArgVectors to use the 32W version? |
| */ |
| BOOL32 WINAPI StartService32A( HANDLE32 hService, DWORD dwNumServiceArgs, |
| LPCSTR *lpServiceArgVectors ) |
| { |
| FIXME(advapi, "(%d,%ld,%p): stub\n",hService,dwNumServiceArgs,lpServiceArgVectors); |
| return TRUE; |
| } |
| |
| |
| /****************************************************************************** |
| * StartService32W [ADVAPI32.198] |
| * Starts a service |
| * |
| * PARAMS |
| * hService [I] Handle of service |
| * dwNumServiceArgs [I] Number of arguments |
| * lpServiceArgVectors [I] Address of array of argument string pointers |
| * |
| * RETURNS STD |
| * |
| * NOTES |
| * hService should be SC_HANDLE |
| */ |
| BOOL32 WINAPI StartService32W( HANDLE32 hService, DWORD dwNumServiceArgs, |
| LPCWSTR *lpServiceArgVectors ) |
| { |
| FIXME(advapi, "(%d,%ld,%p): stub\n",hService,dwNumServiceArgs, |
| lpServiceArgVectors); |
| return TRUE; |
| } |
| |
| |
| /****************************************************************************** |
| * DeregisterEventSource [ADVAPI32.32] |
| * Closes a handle to the specified event log |
| * |
| * PARAMS |
| * hEventLog [I] Handle to event log |
| * |
| * RETURNS STD |
| */ |
| BOOL32 WINAPI DeregisterEventSource( HANDLE32 hEventLog ) |
| { |
| FIXME(advapi, "(%d): stub\n",hEventLog); |
| return TRUE; |
| } |
| |
| |
| /****************************************************************************** |
| * RegisterEventSource32A [ADVAPI32.174] |
| */ |
| HANDLE32 WINAPI RegisterEventSource32A( LPCSTR lpUNCServerName, |
| LPCSTR lpSourceName ) |
| { |
| LPWSTR lpUNCServerNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpUNCServerName); |
| LPWSTR lpSourceNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpSourceName); |
| HANDLE32 ret = RegisterEventSource32W(lpUNCServerNameW,lpSourceNameW); |
| HeapFree(GetProcessHeap(),0,lpSourceNameW); |
| HeapFree(GetProcessHeap(),0,lpUNCServerNameW); |
| return ret; |
| } |
| |
| |
| /****************************************************************************** |
| * RegisterEventSource32W [ADVAPI32.175] |
| * Returns a registered handle to an event log |
| * |
| * PARAMS |
| * lpUNCServerName [I] Server name for source |
| * lpSourceName [I] Source name for registered handle |
| * |
| * RETURNS |
| * Success: Handle |
| * Failure: NULL |
| */ |
| HANDLE32 WINAPI RegisterEventSource32W( LPCWSTR lpUNCServerName, |
| LPCWSTR lpSourceName ) |
| { |
| FIXME(advapi, "(%s,%s): stub\n", debugstr_w(lpUNCServerName), |
| debugstr_w(lpSourceName)); |
| return 1; |
| } |
| |