547 lines
18 KiB
C
547 lines
18 KiB
C
/*
|
|
* 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"
|
|
/***********************************************************************
|
|
* EnumServicesStatus32A [ADVAPI32.37]
|
|
*/
|
|
BOOL32 WINAPI EnumServicesStatus32A( HANDLE32 hSCManager, DWORD dwServiceType,
|
|
DWORD dwServiceState, LPVOID lpServices,
|
|
DWORD cbBufSize, LPDWORD pcbBytesNeeded,
|
|
LPDWORD lpServicesReturned, LPDWORD lpResumeHandle)
|
|
{ FIXME (advapi,"%x type=%lx state=%lx %p %lx %p %p %p\n", hSCManager,
|
|
dwServiceType, dwServiceState, lpServices, cbBufSize,
|
|
pcbBytesNeeded, lpServicesReturned, lpResumeHandle);
|
|
SetLastError (ERROR_ACCESS_DENIED);
|
|
return 0;
|
|
}
|
|
/***********************************************************************
|
|
* StartServiceCtrlDispatcherA [ADVAPI32.196]
|
|
*/
|
|
BOOL32 WINAPI StartServiceCtrlDispatcher32A(LPSERVICE_TABLE_ENTRY32A servent)
|
|
{ LPSERVICE_TABLE_ENTRY32A ptr = servent;
|
|
|
|
while (ptr->lpServiceName)
|
|
{ FIXME(advapi,"%s at %p\n", ptr->lpServiceName, ptr);
|
|
ptr++;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* StartServiceCtrlDispatcherW [ADVAPI32.197]
|
|
*/
|
|
BOOL32 WINAPI StartServiceCtrlDispatcher32W(LPSERVICE_TABLE_ENTRY32W servent)
|
|
{ LPSERVICE_TABLE_ENTRY32W ptr = servent;
|
|
LPSERVICE_MAIN_FUNCTION32W fpMain;
|
|
|
|
while (ptr->lpServiceName)
|
|
{ FIXME(advapi,"%s at %p): STUB.\n", debugstr_w(ptr->lpServiceName),ptr);
|
|
fpMain = ptr->lpServiceProc;
|
|
fpMain(0,NULL); /* try to start the service */
|
|
ptr++;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
typedef DWORD SERVICE_STATUS_HANDLE;
|
|
typedef VOID (WINAPI *LPHANDLER_FUNCTION)( DWORD dwControl);
|
|
/***********************************************************************
|
|
* RegisterServiceCtrlHandlerA [ADVAPI32.176]
|
|
*/
|
|
SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerA (LPSTR lpServiceName, LPHANDLER_FUNCTION lpfHandler)
|
|
{ FIXME(advapi,"%s %p\n", lpServiceName, lpfHandler);
|
|
return 0xcacacafe;
|
|
}
|
|
/***********************************************************************
|
|
* RegisterServiceCtrlHandlerW [ADVAPI32.177]
|
|
*/
|
|
SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerW (LPWSTR lpServiceName, LPHANDLER_FUNCTION lpfHandler)
|
|
{ FIXME(advapi,"%s %p\n", debugstr_w(lpServiceName), lpfHandler);
|
|
return 0xcacacafe;
|
|
}
|
|
/***********************************************************************
|
|
* SetServiceStatus [ADVAPI32.192]
|
|
*/
|
|
BOOL32 WINAPI SetServiceStatus(SERVICE_STATUS_HANDLE hService, LPSERVICE_STATUS lpStatus)
|
|
{ FIXME(advapi,"%lx %p\n",hService, lpStatus);
|
|
TRACE(advapi,"\tType:%lx\n",lpStatus->dwServiceType);
|
|
TRACE(advapi,"\tState:%lx\n",lpStatus->dwCurrentState);
|
|
TRACE(advapi,"\tControlAccepted:%lx\n",lpStatus->dwControlsAccepted);
|
|
TRACE(advapi,"\tExitCode:%lx\n",lpStatus->dwWin32ExitCode);
|
|
TRACE(advapi,"\tServiceExitCode:%lx\n",lpStatus->dwServiceSpecificExitCode);
|
|
TRACE(advapi,"\tCheckPoint:%lx\n",lpStatus->dwCheckPoint);
|
|
TRACE(advapi,"\tWaitHint:%lx\n",lpStatus->dwWaitHint);
|
|
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 tokeninfoclass,LPVOID tokeninfo,
|
|
DWORD tokeninfolength,LPDWORD retlen
|
|
) {
|
|
FIXME(advapi,"(%08x,%d,%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,0x%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;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* GetFileSecurityA [32.45]
|
|
* Obtains Specified information about the security of a file or directory
|
|
* The information obtained is constrained by the callers acces rights and
|
|
* priviliges
|
|
*/
|
|
|
|
BOOL32 WINAPI GetFileSecurity32A( LPCSTR lpFileName,
|
|
SECURITY_INFORMATION RequestedInformation,
|
|
LPSECURITY_DESCRIPTOR pSecurityDescriptor,
|
|
DWORD nLength,
|
|
LPDWORD lpnLengthNeeded)
|
|
{
|
|
FIXME(advapi, "(%s) : stub\n", debugstr_a(lpFileName));
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* GetFileSecurityiW [32.46]
|
|
* Obtains Specified information about the security of a file or directory
|
|
* The information obtained is constrained by the callers acces rights and
|
|
* priviliges
|
|
*/
|
|
|
|
BOOL32 WINAPI GetFileSecurity32W( LPCWSTR lpFileName,
|
|
SECURITY_INFORMATION RequestedInformation,
|
|
LPSECURITY_DESCRIPTOR pSecurityDescriptor,
|
|
DWORD nLength,
|
|
LPDWORD lpnLengthNeeded)
|
|
{
|
|
FIXME(advapi, "(%s) : stub\n", debugstr_w(lpFileName) );
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* SetFileSecurityA [32.182]
|
|
* Sets the security of a file or directory
|
|
*/
|
|
|
|
BOOL32 WINAPI SetFileSecurity32A( LPCSTR lpFileName,
|
|
SECURITY_INFORMATION RequestedInformation,
|
|
LPSECURITY_DESCRIPTOR pSecurityDescriptor)
|
|
{
|
|
FIXME(advapi, "(%s) : stub\n", debugstr_a(lpFileName));
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* SetFileSecurityW [32.183]
|
|
* Sets the security of a file or directory
|
|
*/
|
|
|
|
BOOL32 WINAPI SetFileSecurity32W( LPCWSTR lpFileName,
|
|
SECURITY_INFORMATION RequestedInformation,
|
|
LPSECURITY_DESCRIPTOR pSecurityDescriptor)
|
|
{
|
|
FIXME(advapi, "(%s) : stub\n", debugstr_w(lpFileName) );
|
|
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;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* CreateService32A [ADVAPI32.28]
|
|
*/
|
|
DWORD WINAPI CreateService32A( 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;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* QueryServiceStatus [ADVAPI32]
|
|
*/
|
|
BOOL32 WINAPI QueryServiceStatus(/*SC_HANDLE*/HANDLE32 hService,/*LPSERVICE_STATUS*/LPVOID lpservicestatus) {
|
|
FIXME(advapi,"(%d,%p),stub!\n",hService,lpservicestatus);
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* IsValidSecurityDescriptor [ADVAPI32]
|
|
*/
|
|
BOOL32 WINAPI IsValidSecurityDescriptor(LPSECURITY_DESCRIPTOR lpsecdesc) {
|
|
FIXME(advapi,"(%p),stub!\n",lpsecdesc);
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* MakeSelfRelativeSD [ADVAPI32]
|
|
*/
|
|
BOOL32 WINAPI MakeSelfRelativeSD(
|
|
LPSECURITY_DESCRIPTOR lpabssecdesc,
|
|
LPSECURITY_DESCRIPTOR lpselfsecdesc,LPDWORD lpbuflen
|
|
) {
|
|
FIXME(advapi,"(%p,%p,%p),stub!\n",lpabssecdesc,lpselfsecdesc,lpbuflen);
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* QueryWindows31FilesMigration [ADVAPI32]
|
|
*/
|
|
BOOL32 WINAPI QueryWindows31FilesMigration(DWORD x1) {
|
|
FIXME(advapi,"(%ld),stub!\n",x1);
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* SynchronizeWindows31FilesAndWindowsNTRegistry [ADVAPI32]
|
|
*/
|
|
BOOL32 WINAPI SynchronizeWindows31FilesAndWindowsNTRegistry(DWORD x1,DWORD x2,DWORD x3,DWORD x4) {
|
|
FIXME(advapi,"(0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4);
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* LsaOpenPolicy [ADVAPI32]
|
|
*/
|
|
BOOL32 WINAPI LsaOpenPolicy(DWORD x1,DWORD x2,DWORD x3,DWORD x4) {
|
|
FIXME(advapi,"(0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",x1,x2,x3,x4);
|
|
return 0xc0000000; /* generic error */
|
|
}
|
|
|
|
/******************************************************************************
|
|
* NotifyBootConfigStatus [ADVAPI32]
|
|
*/
|
|
BOOL32 WINAPI NotifyBootConfigStatus(DWORD x1) {
|
|
FIXME(advapi,"(0x%08lx),stub!\n",x1);
|
|
return 1;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* OpenEventLogA [ADVAPI32]
|
|
*/
|
|
HANDLE32 WINAPI OpenEventLog32A(LPCSTR uncname,LPCSTR source) {
|
|
FIXME(advapi,"(%s,%s),stub!\n",uncname,source);
|
|
return 0xcafe4242;
|
|
}
|
|
|