Goto sanos source index
//
// advapi32.c
//
// Win32 ADVAPI32 emulation
//
// Copyright (C) 2002 Michael Ringgaard. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// 3. Neither the name of the project nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
// SUCH DAMAGE.
//
#include <os.h>
#include <sys/types.h>
#include <win32.h>
#include <string.h>
#include <inifile.h>
BOOL WINAPI GetUserNameA(
LPTSTR lpBuffer,
LPDWORD nSize) {
struct passwd *pwd;
TRACE("GetUserNameA");
pwd = getpwuid(getuid());
if (!pwd) return FALSE;
strncpy(lpBuffer, pwd->pw_name, *nSize);
return TRUE;
}
LONG WINAPI RegCloseKey(
HKEY hKey) {
TRACE("RegCloseKey");
syslog(LOG_DEBUG, "warning: RegCloseKey not implemented, ignored");
return -1;
}
LONG WINAPI RegEnumKeyExA(
HKEY hKey,
DWORD dwIndex,
LPTSTR lpName,
LPDWORD lpcName,
LPDWORD lpReserved,
LPTSTR lpClass,
LPDWORD lpcClass,
PFILETIME lpftLastWriteTime) {
TRACE("RegEnumKeyExA");
syslog(LOG_DEBUG, "warning: RegEnumKeyExA ignored");
return -1;
}
LONG WINAPI RegOpenKeyExA(
HKEY hKey,
LPCTSTR lpSubKey,
DWORD ulOptions,
REGSAM samDesired,
PHKEY phkResult) {
TRACE("RegOpenKeyExA");
//syslog(LOG_DEBUG, "warning: RegOpenKeyEx(%p,%s) ignored", hKey, lpSubKey);
return -1;
}
LONG WINAPI RegCreateKeyExA(
HKEY hKey,
LPCSTR lpSubKey,
DWORD Reserved,
LPSTR lpClass,
DWORD dwOptions,
REGSAM samDesired,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
PHKEY phkResult,
LPDWORD lpdwDisposition) {
TRACE("RegCreateKeyExA");
syslog(LOG_DEBUG, "warning: RegCreateKeyExA(%p,%s) ignored", hKey, lpSubKey);
return -1;
}
LONG WINAPI RegEnumValueA(
HKEY hKey,
DWORD dwIndex,
LPSTR lpValueName,
LPDWORD lpcbValueName,
LPDWORD lpReserved,
LPDWORD lpType,
LPBYTE lpData,
LPDWORD lpcbData) {
TRACE("RegEnumValueA");
syslog(LOG_DEBUG, "warning: RegEnumValueA ignored");
return -1;
}
LONG WINAPI RegDeleteValueA(
HKEY hKey,
LPCSTR lpValueName) {
TRACE("RegDeleteValueA");
syslog(LOG_DEBUG, "warning: RegDeleteValueA(%p,%s) ignored", hKey, lpValueName);
return -1;
}
LONG WINAPI RegSetValueExA(
HKEY hKey,
LPCSTR lpValueName,
DWORD Reserved,
DWORD dwType,
CONST BYTE *lpData,
DWORD cbData) {
TRACE("RegSetValueExA");
syslog(LOG_DEBUG, "warning: RegSetValueExA(%p,%s) ignored", hKey, lpValueName);
return -1;
}
LONG WINAPI RegFlushKey(
HKEY hKey
) {
TRACE("RegFlushKey");
syslog(LOG_DEBUG, "warning: RegFlushKey ignored");
return -1;
}
LONG WINAPI RegDeleteKeyA(
HKEY hKey,
LPCSTR lpSubKey) {
TRACE("RegDeleteKeyA");
syslog(LOG_DEBUG, "warning: RegDeleteKeyA(%p,%s) ignored", hKey, lpSubKey);
return -1;
}
LONG WINAPI RegQueryInfoKeyA(
HKEY hKey,
LPTSTR lpClass,
LPDWORD lpcClass,
LPDWORD lpReserved,
LPDWORD lpcSubKeys,
LPDWORD lpcMaxSubKeyLen,
LPDWORD lpcMaxClassLen,
LPDWORD lpcValues,
LPDWORD lpcMaxValueNameLen,
LPDWORD lpcMaxValueLen,
LPDWORD lpcbSecurityDescriptor,
PFILETIME lpftLastWriteTime) {
TRACE("RegQueryInfoKeyA");
syslog(LOG_DEBUG, "warning: RegQueryInfoKeyA ignored");
return -1;
}
LONG WINAPI RegQueryValueExA(
HKEY hKey,
LPCTSTR lpValueName,
LPDWORD lpReserved,
LPDWORD lpType,
LPBYTE lpData,
LPDWORD lpcbData) {
TRACE("RegQueryValueExA");
syslog(LOG_DEBUG, "warning: RegQueryValueExA ignored");
return -1;
}
LONG WINAPI RegQueryValueExW(
HKEY hKey,
LPCWSTR lpValueName,
LPDWORD lpReserved,
LPDWORD lpType,
LPBYTE lpData,
LPDWORD lpcbData) {
TRACE("RegQueryValueExW");
syslog(LOG_DEBUG, "warning: RegQueryValueExW ignored");
return -1;
}
LONG WINAPI RegOpenKeyExW(
HKEY hKey,
LPCWSTR lpSubKey,
DWORD ulOptions,
REGSAM samDesired,
PHKEY phkResult) {
TRACE("RegOpenKeyExW");
syslog(LOG_DEBUG, "warning: RegOpenKeyExW ignored");
return -1;
}
HANDLE WINAPI RegisterEventSourceA(
LPCTSTR lpUNCServerName,
LPCTSTR lpSourceName) {
TRACE("RegisterEventSourceA");
return strdup(lpSourceName);
}
BOOL WINAPI DeregisterEventSource(
HANDLE hEventLog) {
TRACE("DeregisterEventSource");
free(hEventLog);
return TRUE;
}
BOOL WINAPI ReportEventA(
HANDLE hEventLog,
WORD wType,
WORD wCategory,
DWORD dwEventID,
PSID lpUserSid,
WORD wNumStrings,
DWORD dwDataSize,
LPCTSTR *lpStrings,
LPVOID lpRawData) {
int level;
TRACE("ReportEventA");
switch (wType) {
case EVENTLOG_SUCCESS:
level = LOG_NOTICE;
break;
case EVENTLOG_ERROR_TYPE:
level = LOG_ERR;
break;
case EVENTLOG_WARNING_TYPE:
level = LOG_WARNING;
break;
case EVENTLOG_INFORMATION_TYPE:
level = LOG_INFO;
break;
case EVENTLOG_AUDIT_SUCCESS:
level = LOG_INFO;
break;
case EVENTLOG_AUDIT_FAILURE:
level = LOG_WARNING;
break;
default:
level = LOG_DEBUG;
}
if (wNumStrings > 0) {
syslog(level, "%s: %s", hEventLog, lpStrings[0]);
} else {
syslog(level, "%s: message #%d", hEventLog, dwEventID);
}
return TRUE;
}
BOOL WINAPI CryptAcquireContextA(
HCRYPTPROV *phProv,
LPCTSTR pszContainer,
LPCTSTR pszProvider,
DWORD dwProvType,
DWORD dwFlags) {
TRACE("CryptAcquireContextA");
panic("CryptAcquireContextA not implemented");
return TRUE;
}
BOOL WINAPI CryptReleaseContext(
HCRYPTPROV hProv,
DWORD dwFlags) {
TRACE("CryptReleaseContext");
panic("CryptReleaseContext not implemented");
return TRUE;
}
BOOL WINAPI CryptGenRandom(
HCRYPTPROV hProv,
DWORD dwLen,
BYTE *pbBuffer) {
TRACE("CryptGenRandom");
panic("CryptGenRandom not implemented");
return TRUE;
}
BOOL WINAPI StartServiceCtrlDispatcherA(
CONST LPSERVICE_TABLE_ENTRY lpServiceTable) {
TRACE("StartServiceCtrlDispatcherA");
panic("StartServiceCtrlDispatcherA not implemented");
return TRUE;
}
BOOL WINAPI SetServiceStatus(
SERVICE_STATUS_HANDLE hServiceStatus,
LPSERVICE_STATUS lpServiceStatus) {
TRACE("SetServiceStatus");
panic("SetServiceStatus not implemented");
return TRUE;
}
SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerA(
LPCTSTR lpServiceName,
LPHANDLER_FUNCTION lpHandlerProc) {
TRACE("RegisterServiceCtrlHandlerA");
panic("RegisterServiceCtrlHandlerA not implemented");
return 0;
}
BOOL WINAPI AllocateAndInitializeSid(
PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
BYTE nSubAuthorityCount,
DWORD dwSubAuthority0,
DWORD dwSubAuthority1,
DWORD dwSubAuthority2,
DWORD dwSubAuthority3,
DWORD dwSubAuthority4,
DWORD dwSubAuthority5,
DWORD dwSubAuthority6,
DWORD dwSubAuthority7,
PSID *pSid) {
TRACE("AllocateAndInitializeSid");
panic("AllocateAndInitializeSid not implemented");
return FALSE;
}
BOOL WINAPI AddAccessAllowedAce(
PACL pAcl,
DWORD dwAceRevision,
DWORD AccessMask,
PSID pSid) {
TRACE("AddAccessAllowedAce");
panic("AddAccessAllowedAce not implemented");
return FALSE;
}
BOOL WINAPI CopySid(
DWORD nDestinationSidLength,
PSID pDestinationSid,
PSID pSourceSid) {
TRACE("CopySid");
panic("CopySid not implemented");
return FALSE;
}
PVOID WINAPI FreeSid(
PSID pSid) {
TRACE("FreeSid");
panic("FreeSid not implemented");
return NULL;
}
DWORD WINAPI GetLengthSid(
PSID pSid) {
TRACE("GetLengthSid");
panic("GetLengthSid not implemented");
return 0;
}
BOOL WINAPI GetSecurityDescriptorDacl(
PSECURITY_DESCRIPTOR pSecurityDescriptor,
LPBOOL lpbDaclPresent,
PACL *pDacl,
LPBOOL lpbDaclDefaulted) {
TRACE("GetSecurityDescriptorDacl");
panic("GetSecurityDescriptorDacl not implemented");
return FALSE;
}
BOOL WINAPI OpenProcessToken(
HANDLE ProcessHandle,
DWORD DesiredAccess,
PHANDLE TokenHandle) {
TRACE("OpenProcessToken");
panic("OpenProcessToken not implemented");
return FALSE;
}
BOOL WINAPI GetTokenInformation(
HANDLE TokenHandle,
TOKEN_INFORMATION_CLASS TokenInformationClass,
LPVOID TokenInformation,
DWORD TokenInformationLength,
PDWORD ReturnLength) {
TRACE("GetTokenInformation");
panic("GetTokenInformation not implemented");
return FALSE;
}
BOOL WINAPI InitializeAcl(
PACL pAcl,
DWORD nAclLength,
DWORD dwAclRevision) {
TRACE("InitializeAcl");
panic("InitializeAcl not implemented");
return FALSE;
}
BOOL WINAPI InitializeSecurityDescriptor(
PSECURITY_DESCRIPTOR pSecurityDescriptor,
DWORD dwRevision) {
TRACE("InitializeSecurityDescriptor");
panic("InitializeSecurityDescriptor not implemented");
return FALSE;
}
BOOL WINAPI SetSecurityDescriptorDacl(
PSECURITY_DESCRIPTOR pSecurityDescriptor,
BOOL bDaclPresent,
PACL pDacl,
BOOL bDaclDefaulted) {
TRACE("SetSecurityDescriptorDacl");
panic("SetSecurityDescriptorDacl not implemented");
return FALSE;
}
int __stdcall DllMain(handle_t hmod, int reason, void *reserved) {
return TRUE;
}