diff --git a/dlls/advapi32/eventlog.c b/dlls/advapi32/eventlog.c
index cc74f29fa54..b3bf7a60816 100644
--- a/dlls/advapi32/eventlog.c
+++ b/dlls/advapi32/eventlog.c
@@ -6,7 +6,6 @@
 
 #include "winbase.h"
 #include "windef.h"
-#include "winreg.h"
 #include "winerror.h"
 #include "heap.h"
 
diff --git a/dlls/advapi32/security.c b/dlls/advapi32/security.c
index 27332f90de8..15ba8b56f0c 100644
--- a/dlls/advapi32/security.c
+++ b/dlls/advapi32/security.c
@@ -5,10 +5,10 @@
 #include <string.h>
 
 #include "windef.h"
-#include "winreg.h"
 #include "winerror.h"
 #include "heap.h"
 #include "ntddk.h"
+#include "ntsecapi.h"
 #include "debugtools.h"
 
 DECLARE_DEBUG_CHANNEL(advapi)
@@ -22,20 +22,6 @@ DECLARE_DEBUG_CHANNEL(security)
 	  return TRUE; \
 	}
 
-/* FIXME: move it to a header */
-BOOL WINAPI IsValidSid (PSID pSid);
-BOOL WINAPI EqualSid (PSID pSid1, PSID pSid2);
-BOOL WINAPI EqualPrefixSid (PSID pSid1, PSID pSid2);
-DWORD  WINAPI GetSidLengthRequired (BYTE nSubAuthorityCount);
-BOOL WINAPI AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount, DWORD nSubAuthority0, DWORD nSubAuthority1, DWORD nSubAuthority2, DWORD nSubAuthority3,    DWORD nSubAuthority4, DWORD nSubAuthority5, DWORD nSubAuthority6, DWORD nSubAuthority7, PSID *pSid);
-VOID*  WINAPI FreeSid(PSID pSid);
-BOOL WINAPI InitializeSid (PSID pSid, PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount);
-PSID_IDENTIFIER_AUTHORITY WINAPI GetSidIdentifierAuthority(PSID pSid);
-DWORD* WINAPI GetSidSubAuthority(PSID pSid, DWORD nSubAuthority);
-BYTE*  WINAPI GetSidSubAuthorityCount(PSID pSid);
-DWORD  WINAPI GetLengthSid(PSID pSid);
-BOOL WINAPI CopySid(DWORD nDestinationSidLength, PSID pDestinationSid, PSID pSourceSid);
-
 /*	##############################
 	######	TOKEN FUNCTIONS ######
 	##############################
@@ -177,7 +163,7 @@ AllocateAndInitializeSid( PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
  * PARAMS
  *   pSid []
  */
-VOID* WINAPI
+PVOID WINAPI
 FreeSid( PSID pSid )
 {
     HeapFree( GetProcessHeap(), 0, pSid );
@@ -316,7 +302,7 @@ GetSidIdentifierAuthority( PSID pSid )
  *   pSid          []
  *   nSubAuthority []
  */
-DWORD * WINAPI
+PDWORD WINAPI
 GetSidSubAuthority( PSID pSid, DWORD nSubAuthority )
 {
     return &pSid->SubAuthority[nSubAuthority];
@@ -328,7 +314,7 @@ GetSidSubAuthority( PSID pSid, DWORD nSubAuthority )
  * PARAMS
  *   pSid []
  */
-BYTE * WINAPI
+PUCHAR WINAPI
 GetSidSubAuthorityCount (PSID pSid)
 {
     return &pSid->SubAuthorityCount;
@@ -391,7 +377,7 @@ GetSecurityDescriptorOwner( SECURITY_DESCRIPTOR *pDescr, PSID *pOwner,
  *
  * PARAMS
  */
-BOOL SetSecurityDescriptorOwner( PSECURITY_DESCRIPTOR pSecurityDescriptor, 
+BOOL WINAPI SetSecurityDescriptorOwner( PSECURITY_DESCRIPTOR pSecurityDescriptor, 
 				   PSID pOwner, BOOL bOwnerDefaulted)
 {
 	CallWin32ToNt (RtlSetOwnerSecurityDescriptor(pSecurityDescriptor, pOwner, bOwnerDefaulted));
@@ -496,8 +482,8 @@ MakeSelfRelativeSD( PSECURITY_DESCRIPTOR lpabssecdesc,
  * GetSecurityDescriptorControl32			[ADVAPI32]
  */
 
-BOOL GetSecurityDescriptorControl ( PSECURITY_DESCRIPTOR  pSecurityDescriptor,
-		 /* fixme: PSECURITY_DESCRIPTOR_CONTROL*/ LPVOID pControl, LPDWORD lpdwRevision)
+BOOL WINAPI GetSecurityDescriptorControl ( PSECURITY_DESCRIPTOR  pSecurityDescriptor,
+		 PSECURITY_DESCRIPTOR_CONTROL pControl, LPDWORD lpdwRevision)
 {	FIXME_(advapi)("(%p,%p,%p),stub!\n",pSecurityDescriptor,pControl,lpdwRevision);
 	return 1;
 }		
@@ -691,10 +677,15 @@ SynchronizeWindows31FilesAndWindowsNTRegistry( DWORD x1, DWORD x2, DWORD x3,
  *   x3 []
  *   x4 []
  */
-BOOL WINAPI
-LsaOpenPolicy( DWORD x1, DWORD x2, DWORD x3, DWORD x4 )
+NTSTATUS WINAPI
+LsaOpenPolicy(PLSA_UNICODE_STRING SystemName,
+	      PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
+	      ACCESS_MASK DesiredAccess,
+	      PLSA_HANDLE PolicyHandle)
 {
-	FIXME_(advapi)("(0x%08lx,0x%08lx,0x%08lx,0x%08lx):stub\n",x1,x2,x3,x4);
+	FIXME_(advapi)("(%p,%p,0x%08lx,%p):stub\n",
+		       SystemName, ObjectAttributes,
+		       DesiredAccess, PolicyHandle);
 	return 0xc0000000; /* generic error */
 }
 
@@ -728,9 +719,9 @@ RevertToSelf( void )
  * ImpersonateSelf [ADVAPI32.71]
  */
 BOOL WINAPI
-ImpersonateSelf(DWORD/*SECURITY_IMPERSONATION_LEVEL*/ ImpersonationLevel)
+ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
 {
-    FIXME_(advapi)("(%08lx), stub\n", ImpersonationLevel);
+    FIXME_(advapi)("(%08x), stub\n", ImpersonationLevel);
     return TRUE;
 }
 
@@ -738,9 +729,13 @@ ImpersonateSelf(DWORD/*SECURITY_IMPERSONATION_LEVEL*/ ImpersonationLevel)
  * AccessCheck32 [ADVAPI32.71]
  */
 BOOL WINAPI
-AccessCheck(PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, LPVOID/*LPGENERIC_MAPPING*/ GenericMapping, LPVOID/*LPPRIVILEGE_SET*/ PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus)
+AccessCheck(PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken,
+	    DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet,
+	    LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus)
 {
-    FIXME_(advapi)("(%p, %04x, %08lx, %p, %p, %p, %p, %p), stub\n", pSecurityDescriptor, ClientToken, DesiredAccess, GenericMapping, PrivilegeSet, PrivilegeSetLength, GrantedAccess, AccessStatus);
+    FIXME_(advapi)("(%p, %04x, %08lx, %p, %p, %p, %p, %p), stub\n",
+		   pSecurityDescriptor, ClientToken, DesiredAccess, GenericMapping, 
+		   PrivilegeSet, PrivilegeSetLength, GrantedAccess, AccessStatus);
     *AccessStatus = TRUE;
     return TRUE;
 }
diff --git a/dlls/advapi32/service.c b/dlls/advapi32/service.c
index 9f5a7279e14..b07eb8999e2 100644
--- a/dlls/advapi32/service.c
+++ b/dlls/advapi32/service.c
@@ -5,25 +5,21 @@
  */
 
 #include <time.h>
+
 #include "windef.h"
-#include "winreg.h"
+#include "winsvc.h"
 #include "winerror.h"
 #include "heap.h"
 #include "debugtools.h"
 
 DEFAULT_DEBUG_CHANNEL(advapi)
 
-/* FIXME: Where do these belong? */
-typedef DWORD	SERVICE_STATUS_HANDLE;
-typedef VOID (WINAPI *LPHANDLER_FUNCTION)( DWORD dwControl);
-
-
 /******************************************************************************
  * EnumServicesStatus32A [ADVAPI32.38]
  */
 BOOL WINAPI
-EnumServicesStatusA( HANDLE hSCManager, DWORD dwServiceType,
-                       DWORD dwServiceState, LPVOID lpServices,
+EnumServicesStatusA( SC_HANDLE hSCManager, DWORD dwServiceType,
+                       DWORD dwServiceState, LPENUM_SERVICE_STATUSA lpServices,
                        DWORD cbBufSize, LPDWORD pcbBytesNeeded,
                        LPDWORD lpServicesReturned, LPDWORD lpResumeHandle )
 {	FIXME("%x type=%lx state=%lx %p %lx %p %p %p\n", hSCManager, 
@@ -71,7 +67,7 @@ StartServiceCtrlDispatcherW( LPSERVICE_TABLE_ENTRYW servent )
  * RegisterServiceCtrlHandlerA [ADVAPI32.176]
  */
 SERVICE_STATUS_HANDLE WINAPI
-RegisterServiceCtrlHandlerA( LPSTR lpServiceName,
+RegisterServiceCtrlHandlerA( LPCSTR lpServiceName,
                              LPHANDLER_FUNCTION lpfHandler )
 {	FIXME("%s %p\n", lpServiceName, lpfHandler);
 	return 0xcacacafe;	
@@ -85,7 +81,7 @@ RegisterServiceCtrlHandlerA( LPSTR lpServiceName,
  *   lpfHandler    []
  */
 SERVICE_STATUS_HANDLE WINAPI
-RegisterServiceCtrlHandlerW( LPWSTR lpServiceName, 
+RegisterServiceCtrlHandlerW( LPCWSTR lpServiceName, 
                              LPHANDLER_FUNCTION lpfHandler )
 {	FIXME("%s %p\n", debugstr_w(lpServiceName), lpfHandler);
 	return 0xcacacafe;	
@@ -114,7 +110,7 @@ SetServiceStatus( SERVICE_STATUS_HANDLE hService, LPSERVICE_STATUS lpStatus )
 /******************************************************************************
  * OpenSCManager32A [ADVAPI32.110]
  */
-HANDLE WINAPI
+SC_HANDLE WINAPI
 OpenSCManagerA( LPCSTR lpMachineName, LPCSTR lpDatabaseName,
                   DWORD dwDesiredAccess )
 {   
@@ -143,7 +139,7 @@ OpenSCManagerA( LPCSTR lpMachineName, LPCSTR lpDatabaseName,
  *   Success: Handle to service control manager database
  *   Failure: NULL
  */
-HANDLE WINAPI
+SC_HANDLE WINAPI
 OpenSCManagerW( LPCWSTR lpMachineName, LPCWSTR lpDatabaseName,
                   DWORD dwDesiredAccess )
 {
@@ -177,13 +173,10 @@ AllocateLocallyUniqueId( PLUID lpluid )
  *   dwControl       []
  *   lpServiceStatus []
  *
- * NOTES
- *    hService should be SC_HANDLE
- *
  * RETURNS STD
  */
 BOOL WINAPI
-ControlService( HANDLE hService, DWORD dwControl, 
+ControlService( SC_HANDLE hService, DWORD dwControl, 
                 LPSERVICE_STATUS lpServiceStatus )
 {
     FIXME("(%d,%ld,%p): stub\n",hService,dwControl,lpServiceStatus);
@@ -198,13 +191,10 @@ ControlService( HANDLE hService, DWORD dwControl,
  * PARAMS
  *   hSCObject [I] Handle to service or service control manager database
  *
- * NOTES
- *   hSCObject should be SC_HANDLE
- *
  * RETURNS STD
  */
 BOOL WINAPI
-CloseServiceHandle( HANDLE hSCObject )
+CloseServiceHandle( SC_HANDLE hSCObject )
 {
     FIXME("(%d): stub\n", hSCObject);
     return TRUE;
@@ -214,8 +204,8 @@ CloseServiceHandle( HANDLE hSCObject )
 /******************************************************************************
  * OpenService32A [ADVAPI32.112]
  */
-HANDLE WINAPI
-OpenServiceA( HANDLE hSCManager, LPCSTR lpServiceName, 
+SC_HANDLE WINAPI
+OpenServiceA( SC_HANDLE hSCManager, LPCSTR lpServiceName, 
                 DWORD dwDesiredAccess )
 {
     LPWSTR lpServiceNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpServiceName);
@@ -234,16 +224,12 @@ OpenServiceA( HANDLE hSCManager, LPCSTR lpServiceName,
  *   lpServiceName   []
  *   dwDesiredAccess []
  *
- * NOTES
- *    The return value should be SC_HANDLE
- *    hSCManager should be SC_HANDLE
- *
  * RETURNS
  *    Success: Handle to the service
  *    Failure: NULL
  */
-HANDLE WINAPI
-OpenServiceW(HANDLE hSCManager, LPCWSTR lpServiceName,
+SC_HANDLE WINAPI
+OpenServiceW(SC_HANDLE hSCManager, LPCWSTR lpServiceName,
                DWORD dwDesiredAccess)
 {
     FIXME("(%d,%p,%ld): stub\n",hSCManager, lpServiceName,
@@ -255,7 +241,7 @@ OpenServiceW(HANDLE hSCManager, LPCWSTR lpServiceName,
 /******************************************************************************
  * CreateService32A [ADVAPI32.29]
  */
-DWORD WINAPI
+SC_HANDLE WINAPI
 CreateServiceA( DWORD hSCManager, LPCSTR lpServiceName,
                   LPCSTR lpDisplayName, DWORD dwDesiredAccess, 
                   DWORD dwServiceType, DWORD dwStartType, 
@@ -278,11 +264,9 @@ CreateServiceA( DWORD hSCManager, LPCSTR lpServiceName,
  *
  * RETURNS STD
  *
- * NOTES
- *    hService should be SC_HANDLE
  */
 BOOL WINAPI
-DeleteService( HANDLE hService )
+DeleteService( SC_HANDLE hService )
 {
     FIXME("(%d): stub\n",hService);
     return TRUE;
@@ -296,7 +280,7 @@ DeleteService( HANDLE hService )
  *    How do we convert lpServiceArgVectors to use the 32W version?
  */
 BOOL WINAPI
-StartServiceA( HANDLE hService, DWORD dwNumServiceArgs,
+StartServiceA( SC_HANDLE hService, DWORD dwNumServiceArgs,
                  LPCSTR *lpServiceArgVectors )
 {
     FIXME("(%d,%ld,%p): stub\n",hService,dwNumServiceArgs,lpServiceArgVectors);
@@ -315,11 +299,9 @@ StartServiceA( HANDLE hService, DWORD dwNumServiceArgs,
  *
  * RETURNS STD
  *
- * NOTES
- *   hService should be SC_HANDLE
  */
 BOOL WINAPI
-StartServiceW( HANDLE hService, DWORD dwNumServiceArgs,
+StartServiceW( SC_HANDLE hService, DWORD dwNumServiceArgs,
                  LPCWSTR *lpServiceArgVectors )
 {
     FIXME("(%d,%ld,%p): stub\n",hService,dwNumServiceArgs,
@@ -334,12 +316,9 @@ StartServiceW( HANDLE hService, DWORD dwNumServiceArgs,
  *   hService        []
  *   lpservicestatus []
  *   
- * FIXME
- *   hService should be SC_HANDLE
- *   lpservicestatus should be LPSERVICE_STATUS
  */
 BOOL WINAPI
-QueryServiceStatus( HANDLE hService, LPVOID lpservicestatus )
+QueryServiceStatus( SC_HANDLE hService, LPSERVICE_STATUS lpservicestatus )
 {
 	FIXME("(%d,%p),stub!\n",hService,lpservicestatus);
 	return TRUE;
diff --git a/include/ntddk.h b/include/ntddk.h
index 937f32f3099..7c49bcdf618 100644
--- a/include/ntddk.h
+++ b/include/ntddk.h
@@ -572,7 +572,7 @@ BOOLEAN WINAPI RtlFreeHeap(
 /*
  *	misc
  */
-void __cdecl DbgPrint(LPCSTR fmt,LPVOID args);
+void WINAPIV DbgPrint(LPCSTR fmt, ...);
 DWORD WINAPI NtRaiseException(PEXCEPTION_RECORD,PCONTEXT,BOOL);
 void WINAPI RtlRaiseException(PEXCEPTION_RECORD);
 void WINAPI RtlRaiseStatus(NTSTATUS);
diff --git a/include/ntsecapi.h b/include/ntsecapi.h
new file mode 100644
index 00000000000..ec3a19f6e52
--- /dev/null
+++ b/include/ntsecapi.h
@@ -0,0 +1,22 @@
+#ifndef __WINE_NTSECAPI_H
+#define __WINE_NTSECAPI_H
+
+#include "ntdef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* defined(__cplusplus) */
+
+typedef UNICODE_STRING LSA_UNICODE_STRING, *PLSA_UNICODE_STRING;
+typedef STRING LSA_STRING, *PLSA_STRING;
+typedef OBJECT_ATTRIBUTES LSA_OBJECT_ATTRIBUTES, *PLSA_OBJECT_ATTRIBUTES;
+
+typedef PVOID LSA_HANDLE, *PLSA_HANDLE;
+
+NTSTATUS WINAPI LsaOpenPolicy(PLSA_UNICODE_STRING,PLSA_OBJECT_ATTRIBUTES,ACCESS_MASK,PLSA_HANDLE);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* defined(__cplusplus) */
+
+#endif /* !defined(__WINE_NTSECAPI_H) */
diff --git a/include/winbase.h b/include/winbase.h
index a71aebee321..0fcd0a82f7a 100644
--- a/include/winbase.h
+++ b/include/winbase.h
@@ -814,27 +814,6 @@ typedef struct tagSYSTEM_INFO
     WORD	wProcessorRevision;
 } SYSTEM_INFO, *LPSYSTEM_INFO;
 
-/* service main function prototype */
-typedef VOID (CALLBACK *LPSERVICE_MAIN_FUNCTIONA)(DWORD,LPSTR);
-typedef VOID (CALLBACK *LPSERVICE_MAIN_FUNCTIONW)(DWORD,LPWSTR);
-DECL_WINELIB_TYPE_AW(LPSERVICE_MAIN_FUNCTION)
-
-/* service start table */
-typedef struct
-{
-    LPSTR			lpServiceName;
-    LPSERVICE_MAIN_FUNCTIONA	lpServiceProc;
-} *LPSERVICE_TABLE_ENTRYA, SERVICE_TABLE_ENTRYA;
-
-typedef struct
-{
-    LPWSTR			lpServiceName;
-    LPSERVICE_MAIN_FUNCTIONW	lpServiceProc;
-} *LPSERVICE_TABLE_ENTRYW, SERVICE_TABLE_ENTRYW;
-
-DECL_WINELIB_TYPE_AW(SERVICE_TABLE_ENTRY)
-DECL_WINELIB_TYPE_AW(LPSERVICE_TABLE_ENTRY)
-
 /* {G,S}etPriorityClass */
 #define	NORMAL_PRIORITY_CLASS	0x00000020
 #define	IDLE_PRIORITY_CLASS	0x00000040
@@ -1185,9 +1164,21 @@ BOOL16      WINAPI GetWinDebugInfo16(LPWINDEBUGINFO,UINT16);
 BOOL16      WINAPI SetWinDebugInfo16(LPWINDEBUGINFO);
 /* Declarations for functions that exist only in Win32 */
 
+
+BOOL        WINAPI AccessCheck(PSECURITY_DESCRIPTOR,HANDLE,DWORD,PGENERIC_MAPPING,PPRIVILEGE_SET,LPDWORD,LPDWORD,LPBOOL);
+BOOL        WINAPI AdjustTokenPrivileges(HANDLE,BOOL,LPVOID,DWORD,LPVOID,LPDWORD);
+BOOL        WINAPI AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY,BYTE,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,PSID *);
+BOOL        WINAPI AllocateLocallyUniqueId(PLUID);
 BOOL      WINAPI AllocConsole(void);
 BOOL      WINAPI AreFileApisANSI(void);
+BOOL        WINAPI BackupEventLogA(HANDLE,LPCSTR);
+BOOL        WINAPI BackupEventLogW(HANDLE,LPCWSTR);
+#define     BackupEventLog WINELIB_NAME_AW(BackupEventLog)
 BOOL      WINAPI Beep(DWORD,DWORD);
+BOOL        WINAPI ClearEventLogA(HANDLE,LPCSTR);
+BOOL        WINAPI ClearEventLogW(HANDLE,LPCWSTR);
+#define     ClearEventLog WINELIB_NAME_AW(ClearEventLog)
+BOOL        WINAPI CloseEventLog(HANDLE);
 BOOL      WINAPI CloseHandle(HANDLE);
 BOOL      WINAPI ContinueDebugEvent(DWORD,DWORD,DWORD);
 HANDLE    WINAPI ConvertToGlobalHandle(HANDLE hSrc);
@@ -1197,6 +1188,7 @@ BOOL      WINAPI CopyFileW(LPCWSTR,LPCWSTR,BOOL);
 BOOL      WINAPI CopyFileExA(LPCSTR, LPCSTR, LPPROGRESS_ROUTINE, LPVOID, LPBOOL, DWORD);
 BOOL      WINAPI CopyFileExW(LPCWSTR, LPCWSTR, LPPROGRESS_ROUTINE, LPVOID, LPBOOL, DWORD);
 #define     CopyFileEx WINELIB_NAME_AW(CopyFileEx)
+BOOL        WINAPI CopySid(DWORD,PSID,PSID);
 INT       WINAPI CompareFileTime(LPFILETIME,LPFILETIME);
 HANDLE    WINAPI CreateEventA(LPSECURITY_ATTRIBUTES,BOOL,BOOL,LPCSTR);
 HANDLE    WINAPI CreateEventW(LPSECURITY_ATTRIBUTES,BOOL,BOOL,LPCWSTR);
@@ -1228,6 +1220,7 @@ HANDLE    WINAPI CreateSemaphoreW(LPSECURITY_ATTRIBUTES,LONG,LONG,LPCWSTR);
 HANDLE      WINAPI CreateThread(LPSECURITY_ATTRIBUTES,DWORD,LPTHREAD_START_ROUTINE,LPVOID,DWORD,LPDWORD);
 BOOL        WINAPI DebugActiveProcess(DWORD);
 void        WINAPI DebugBreak(void);
+BOOL        WINAPI DeregisterEventSource(HANDLE);
 BOOL        WINAPI DisableThreadLibraryCalls(HMODULE);
 BOOL        WINAPI DosDateTimeToFileTime(WORD,WORD,LPFILETIME);
 BOOL        WINAPI DuplicateHandle(HANDLE,HANDLE,HANDLE,HANDLE*,DWORD,BOOL,DWORD);
@@ -1256,6 +1249,8 @@ BOOL      WINAPI EnumSystemLocalesW(LOCALE_ENUMPROCW,DWORD);
 BOOL      WINAPI EnumTimeFormatsA(TIMEFMT_ENUMPROCA lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags);
 BOOL      WINAPI EnumTimeFormatsW(TIMEFMT_ENUMPROCW lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags);
 #define     EnumTimeFormats WINELIB_NAME_AW(EnumTimeFormats)
+BOOL        WINAPI EqualSid(PSID, PSID);
+BOOL        WINAPI EqualPrefixSid(PSID,PSID);
 VOID        WINAPI ExitProcess(DWORD);
 VOID        WINAPI ExitThread(DWORD);
 DWORD       WINAPI ExpandEnvironmentStringsA(LPCSTR,LPSTR,DWORD);
@@ -1284,6 +1279,7 @@ BOOL      WINAPI FreeConsole(void);
 BOOL      WINAPI FreeEnvironmentStringsA(LPSTR);
 BOOL      WINAPI FreeEnvironmentStringsW(LPWSTR);
 #define     FreeEnvironmentStrings WINELIB_NAME_AW(FreeEnvironmentStrings)
+PVOID       WINAPI FreeSid(PSID);
 UINT      WINAPI GetACP(void);
 LPCSTR      WINAPI GetCommandLineA(void);
 LPCWSTR     WINAPI GetCommandLineW(void);
@@ -1316,6 +1312,9 @@ BOOL      WINAPI GetFileAttributesExA(LPCSTR,GET_FILEEX_INFO_LEVELS,LPVOID);
 BOOL      WINAPI GetFileAttributesExW(LPCWSTR,GET_FILEEX_INFO_LEVELS,LPVOID);
 #define     GetFileattributesEx WINELIB_NAME_AW(GetFileAttributesEx)
 DWORD       WINAPI GetFileInformationByHandle(HFILE,BY_HANDLE_FILE_INFORMATION*);
+BOOL        WINAPI GetFileSecurityA(LPCSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,LPDWORD);
+BOOL        WINAPI GetFileSecurityW(LPCWSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,LPDWORD);
+#define     GetFileSecurity WINELIB_NAME_AW(GetFileSecurity)
 DWORD       WINAPI GetFileSize(HFILE,LPDWORD);
 BOOL      WINAPI GetFileTime(HFILE,LPFILETIME,LPFILETIME,LPFILETIME);
 DWORD       WINAPI GetFileType(HFILE);
@@ -1324,6 +1323,7 @@ DWORD       WINAPI GetFullPathNameW(LPCWSTR,DWORD,LPWSTR,LPWSTR*);
 #define     GetFullPathName WINELIB_NAME_AW(GetFullPathName)
 BOOL      WINAPI GetHandleInformation(HANDLE,LPDWORD);
 DWORD       WINAPI GetLargestConsoleWindowSize(HANDLE);
+DWORD       WINAPI GetLengthSid(PSID);
 VOID        WINAPI GetLocalTime(LPSYSTEMTIME);
 DWORD       WINAPI GetLogicalDrives(void);
 DWORD       WINAPI GetLongPathNameA(LPCSTR,LPSTR,DWORD);
@@ -1331,10 +1331,22 @@ DWORD       WINAPI GetLongPathNameW(LPCWSTR,LPWSTR,DWORD);
 #define     GetLongPathName WINELIB_NAME_AW(GetLongPathName)
 BOOL      WINAPI GetNumberOfConsoleInputEvents(HANDLE,LPDWORD);
 BOOL      WINAPI GetNumberOfConsoleMouseButtons(LPDWORD);
+BOOL        WINAPI GetNumberOfEventLogRecords(HANDLE,PDWORD);
 UINT      WINAPI GetOEMCP(void);
+BOOL        WINAPI GetOldestEventLogRecord(HANDLE,PDWORD);
 DWORD       WINAPI GetPriorityClass(HANDLE);
 HANDLE    WINAPI GetProcessHeap(void);
 DWORD       WINAPI GetProcessVersion(DWORD);
+BOOL        WINAPI GetSecurityDescriptorControl(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR_CONTROL,LPDWORD);
+BOOL        WINAPI GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR,LPBOOL,PACL *,LPBOOL);
+BOOL        WINAPI GetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR,PSID *,LPBOOL);
+DWORD       WINAPI GetSecurityDescriptorLength(PSECURITY_DESCRIPTOR);
+BOOL        WINAPI GetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR,PSID *,LPBOOL);
+BOOL        WINAPI GetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR,LPBOOL,PACL *,LPBOOL);
+PSID_IDENTIFIER_AUTHORITY WINAPI GetSidIdentifierAuthority(PSID);
+DWORD       WINAPI GetSidLengthRequired(BYTE);
+PDWORD      WINAPI GetSidSubAuthority(PSID,DWORD);
+PUCHAR      WINAPI GetSidSubAuthorityCount(PSID);
 DWORD       WINAPI GetShortPathNameA(LPCSTR,LPSTR,DWORD);
 DWORD       WINAPI GetShortPathNameW(LPCWSTR,LPWSTR,DWORD);
 #define     GetShortPathName WINELIB_NAME_AW(GetShortPathName)
@@ -1351,6 +1363,10 @@ INT       WINAPI GetTimeFormatW(LCID,DWORD,LPSYSTEMTIME,LPCWSTR,LPWSTR,INT);
 LCID        WINAPI GetThreadLocale(void);
 INT       WINAPI GetThreadPriority(HANDLE);
 BOOL      WINAPI GetThreadSelectorEntry(HANDLE,DWORD,LPLDT_ENTRY);
+BOOL        WINAPI GetTokenInformation(HANDLE,TOKEN_INFORMATION_CLASS,LPVOID,DWORD,LPDWORD);
+BOOL        WINAPI GetUserNameA(LPSTR,LPDWORD);
+BOOL        WINAPI GetUserNameW(LPWSTR,LPDWORD);
+#define     GetUserName WINELIB_NAME_AW(GetUserName)
 VOID        WINAPI GlobalMemoryStatus(LPMEMORYSTATUS);
 LPVOID      WINAPI HeapAlloc(HANDLE,DWORD,DWORD);
 DWORD       WINAPI HeapCompact(HANDLE,DWORD);
@@ -1362,6 +1378,10 @@ LPVOID      WINAPI HeapReAlloc(HANDLE,DWORD,LPVOID,DWORD);
 DWORD       WINAPI HeapSize(HANDLE,DWORD,LPVOID);
 BOOL      WINAPI HeapUnlock(HANDLE);
 BOOL      WINAPI HeapValidate(HANDLE,DWORD,LPCVOID);
+BOOL        WINAPI InitializeSid(PSID,PSID_IDENTIFIER_AUTHORITY,BYTE);
+BOOL        WINAPI IsValidSecurityDescriptor(PSECURITY_DESCRIPTOR);
+BOOL        WINAPI IsValidSid(PSID);
+BOOL        WINAPI ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL);
 LONG        WINAPI InterlockedDecrement(LPLONG);
 LONG        WINAPI InterlockedExchange(LPLONG,LONG);
 LONG        WINAPI InterlockedIncrement(LPLONG);
@@ -1371,6 +1391,10 @@ BOOL      WINAPI IsValidLocale(DWORD,DWORD);
 BOOL      WINAPI LocalFileTimeToFileTime(const FILETIME*,LPFILETIME);
 BOOL      WINAPI LockFile(HFILE,DWORD,DWORD,DWORD,DWORD);
 BOOL      WINAPI LockFileEx(HANDLE, DWORD, DWORD, DWORD, DWORD, LPOVERLAPPED);    
+BOOL        WINAPI LookupPrivilegeValueA(LPCSTR,LPCSTR,LPVOID);
+BOOL        WINAPI LookupPrivilegeValueW(LPCWSTR,LPCWSTR,LPVOID);
+#define     LookupPrivilegeValue WINELIB_NAME_AW(LookupPrivilegeValue)
+BOOL        WINAPI MakeSelfRelativeSD(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,LPDWORD);
 HMODULE   WINAPI MapHModuleSL(HMODULE16);
 HMODULE16   WINAPI MapHModuleLS(HMODULE);
 SEGPTR      WINAPI MapLS(LPVOID);
@@ -1384,10 +1408,17 @@ BOOL      WINAPI MoveFileExA(LPCSTR,LPCSTR,DWORD);
 BOOL      WINAPI MoveFileExW(LPCWSTR,LPCWSTR,DWORD);
 #define     MoveFileEx WINELIB_NAME_AW(MoveFileEx)
 INT       WINAPI MultiByteToWideChar(UINT,DWORD,LPCSTR,INT,LPWSTR,INT);
+BOOL        WINAPI NotifyChangeEventLog(HANDLE,HANDLE);
 INT       WINAPI WideCharToMultiByte(UINT,DWORD,LPCWSTR,INT,LPSTR,INT,LPCSTR,BOOL*);
+HANDLE      WINAPI OpenBackupEventLogA(LPCSTR,LPCSTR);
+HANDLE      WINAPI OpenBackupEventLogW(LPCWSTR,LPCWSTR);
+#define     OpenBackupEventLog WINELIB_NAME_AW(OpenBackupEventLog)
 HANDLE    WINAPI OpenEventA(DWORD,BOOL,LPCSTR);
 HANDLE    WINAPI OpenEventW(DWORD,BOOL,LPCWSTR);
 #define     OpenEvent WINELIB_NAME_AW(OpenEvent)
+HANDLE      WINAPI OpenEventLogA(LPCSTR,LPCSTR);
+HANDLE      WINAPI OpenEventLogW(LPCWSTR,LPCWSTR);
+#define     OpenEventLog WINELIB_NAME_AW(OpenEventLog)
 HANDLE    WINAPI OpenFileMappingA(DWORD,BOOL,LPCSTR);
 HANDLE    WINAPI OpenFileMappingW(DWORD,BOOL,LPCWSTR);
 #define     OpenFileMapping WINELIB_NAME_AW(OpenFileMapping)
@@ -1395,9 +1426,11 @@ HANDLE    WINAPI OpenMutexA(DWORD,BOOL,LPCSTR);
 HANDLE    WINAPI OpenMutexW(DWORD,BOOL,LPCWSTR);
 #define     OpenMutex WINELIB_NAME_AW(OpenMutex)
 HANDLE    WINAPI OpenProcess(DWORD,BOOL,DWORD);
+BOOL        WINAPI OpenProcessToken(HANDLE,DWORD,PHANDLE);
 HANDLE    WINAPI OpenSemaphoreA(DWORD,BOOL,LPCSTR);
 HANDLE    WINAPI OpenSemaphoreW(DWORD,BOOL,LPCWSTR);
 #define     OpenSemaphore WINELIB_NAME_AW(OpenSemaphore)
+BOOL        WINAPI OpenThreadToken(HANDLE,DWORD,BOOL,PHANDLE);
 BOOL      WINAPI PulseEvent(HANDLE);
 BOOL      WINAPI PurgeComm(HANDLE,DWORD);
 DWORD       WINAPI QueryDosDeviceA(LPCSTR,LPSTR,DWORD);
@@ -1410,9 +1443,18 @@ BOOL      WINAPI ReadConsoleW(HANDLE,LPVOID,DWORD,LPDWORD,LPVOID);
 BOOL      WINAPI ReadConsoleOutputCharacterA(HANDLE,LPSTR,DWORD,
 						 COORD,LPDWORD);
 #define     ReadConsoleOutputCharacter WINELIB_NAME_AW(ReadConsoleOutputCharacter)
+BOOL        WINAPI ReadEventLogA(HANDLE,DWORD,DWORD,LPVOID,DWORD,DWORD *,DWORD *);
+BOOL        WINAPI ReadEventLogW(HANDLE,DWORD,DWORD,LPVOID,DWORD,DWORD *,DWORD *);
+#define     ReadEventLog WINELIB_NAME_AW(ReadEventLog)
 BOOL      WINAPI ReadFile(HANDLE,LPVOID,DWORD,LPDWORD,LPOVERLAPPED);
+HANDLE      WINAPI RegisterEventSourceA(LPCSTR,LPCSTR);
+HANDLE      WINAPI RegisterEventSourceW(LPCWSTR,LPCWSTR);
+#define     RegisterEventSource WINELIB_NAME_AW(RegisterEventSource)
 BOOL      WINAPI ReleaseMutex(HANDLE);
 BOOL      WINAPI ReleaseSemaphore(HANDLE,LONG,LPLONG);
+BOOL        WINAPI ReportEventA(HANDLE,WORD,WORD,DWORD,PSID,WORD,DWORD,LPCSTR *,LPVOID);
+BOOL        WINAPI ReportEventW(HANDLE,WORD,WORD,DWORD,PSID,WORD,DWORD,LPCWSTR *,LPVOID);
+#define     ReportEvent WINELIB_NAME_AW(ReportEvent)
 BOOL      WINAPI ResetEvent(HANDLE);
 DWORD       WINAPI ResumeThread(HANDLE);
 VOID        WINAPI RtlFillMemory(LPVOID,UINT,UINT);
@@ -1423,6 +1465,7 @@ VOID        WINAPI RtlZeroMemory(LPVOID,UINT);
 #define     ZeroMemory RtlZeroMemory
 VOID        WINAPI RtlCopyMemory(LPVOID,const VOID*, DWORD);
 #define     CopyMemory RtlCopyMemory
+BOOL        WINAPI RevertToSelf(void);
 DWORD       WINAPI SearchPathA(LPCSTR,LPCSTR,LPCSTR,DWORD,LPSTR,LPSTR*);
 DWORD       WINAPI SearchPathW(LPCWSTR,LPCWSTR,LPCWSTR,DWORD,LPWSTR,LPWSTR*);
 #define     SearchPath WINELIB_NAME_AW(SearchPath)
@@ -1443,10 +1486,17 @@ BOOL      WINAPI SetEvent(HANDLE);
 VOID        WINAPI SetFileApisToANSI(void);
 VOID        WINAPI SetFileApisToOEM(void);
 DWORD       WINAPI SetFilePointer(HFILE,LONG,LPLONG,DWORD);
+BOOL        WINAPI SetFileSecurityA(LPCSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
+BOOL        WINAPI SetFileSecurityW(LPCWSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
+#define     SetFileSecurity WINELIB_NAME_AW(SetFileSecurity)
 BOOL      WINAPI SetFileTime(HFILE,const FILETIME*,const FILETIME*,
                                const FILETIME*);
 BOOL      WINAPI SetHandleInformation(HANDLE,DWORD,DWORD);
 BOOL      WINAPI SetPriorityClass(HANDLE,DWORD);
+BOOL        WINAPI SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR,BOOL,PACL,BOOL);
+BOOL        WINAPI SetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR,PSID,BOOL);
+BOOL        WINAPI SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR,PSID,BOOL);
+BOOL        WINAPI SetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR,BOOL,PACL,BOOL);
 BOOL      WINAPI SetStdHandle(DWORD,HANDLE);
 BOOL      WINAPI SetSystemPowerState(BOOL,BOOL);
 BOOL      WINAPI SetSystemTime(const SYSTEMTIME*);
diff --git a/include/windef.h b/include/windef.h
index c28cc1b80b5..eee23d568e5 100644
--- a/include/windef.h
+++ b/include/windef.h
@@ -146,8 +146,6 @@ typedef LONG            LRESULT;
 typedef WORD            ATOM;
 typedef WORD            CATCHBUF[9];
 typedef WORD           *LPCATCHBUF;
-typedef DWORD           ACCESS_MASK;
-typedef ACCESS_MASK     REGSAM;
 typedef HANDLE          HHOOK;
 typedef HANDLE          HMONITOR;
 typedef DWORD           LCID;
diff --git a/include/winnt.h b/include/winnt.h
index 5a40b4823d7..1f3c01650c6 100644
--- a/include/winnt.h
+++ b/include/winnt.h
@@ -560,16 +560,31 @@ typedef enum _TOKEN_INFORMATION_CLASS {
 
 #include "pshpack1.h"
 
+typedef DWORD ACCESS_MASK, *PACCESS_MASK;
+
+typedef struct _GENERIC_MAPPING {
+    ACCESS_MASK GenericRead;
+    ACCESS_MASK GenericWrite;
+    ACCESS_MASK GenericExecute;
+    ACCESS_MASK GenericAll;
+} GENERIC_MAPPING, *PGENERIC_MAPPING;
+
+#ifndef SID_IDENTIFIER_AUTHORITY_DEFINED
+#define SID_IDENTIFIER_AUTHORITY_DEFINED
 typedef struct {
     BYTE Value[6];
 } SID_IDENTIFIER_AUTHORITY,*PSID_IDENTIFIER_AUTHORITY,*LPSID_IDENTIFIER_AUTHORITY;
+#endif /* !defined(SID_IDENTIFIER_AUTHORITY_DEFINED) */
 
+#ifndef SID_DEFINED
+#define SID_DEFINED
 typedef struct _SID {
     BYTE Revision;
     BYTE SubAuthorityCount;
     SID_IDENTIFIER_AUTHORITY IdentifierAuthority;
     DWORD SubAuthority[1];
 } SID,*PSID;
+#endif /* !defined(SID_DEFINED) */
 
 #define	SID_REVISION			(1)	/* Current revision */
 #define	SID_MAX_SUB_AUTHORITIES		(15)	/* current max subauths */
@@ -601,8 +616,8 @@ typedef struct _ACL {
 #define	SE_SACL_DEFAULTED	0x0020
 #define	SE_SELF_RELATIVE	0x8000
 
-typedef DWORD SECURITY_INFORMATION;
-typedef WORD SECURITY_DESCRIPTOR_CONTROL;
+typedef DWORD SECURITY_INFORMATION, *PSECURITY_INFORMATION;
+typedef WORD SECURITY_DESCRIPTOR_CONTROL, *PSECURITY_DESCRIPTOR_CONTROL;
 
 /* The security descriptor structure */
 typedef struct {
@@ -676,6 +691,16 @@ typedef struct _LUID_AND_ATTRIBUTES {
   DWORD  Attributes; 
 } LUID_AND_ATTRIBUTES; 
 
+/*
+ * PRIVILEGE_SET
+ */
+
+typedef struct _PRIVILEGE_SET {
+    DWORD PrivilegeCount;
+    DWORD Control;
+    LUID_AND_ATTRIBUTES Privilege[ANYSIZE_ARRAY];
+} PRIVILEGE_SET, *PPRIVILEGE_SET;
+
 /*
  * TOKEN_PRIVILEGES
  */
@@ -737,7 +762,7 @@ typedef enum _SECURITY_IMPERSONATION_LEVEL {
   SecurityIdentification, 
   SecurityImpersonation, 
   SecurityDelegation 
-} SECURITY_IMPERSONATION_LEVEL; 
+} SECURITY_IMPERSONATION_LEVEL, *PSECURITY_IMPERSONATION_LEVEL; 
 
 
 typedef BOOLEAN SECURITY_CONTEXT_TRACKING_MODE,
diff --git a/include/winreg.h b/include/winreg.h
index b66fc3a2f23..c7fd07acc4d 100644
--- a/include/winreg.h
+++ b/include/winreg.h
@@ -101,30 +101,8 @@ typedef struct value_entW {
     DWORD	ve_type;
 } VALENTW, *PVALENTW;
 
+typedef ACCESS_MASK REGSAM;
 
-/* Used by: ControlService */
-typedef struct _SERVICE_STATUS {
-    DWORD dwServiceType;
-    DWORD dwCurrentState;
-    DWORD dwControlsAccepted;
-    DWORD dwWin32ExitCode;
-    DWORD dwServiceSpecificExitCode;
-    DWORD dwCheckPoint;
-    DWORD dwWaitHint;
-} SERVICE_STATUS, *LPSERVICE_STATUS;
-
-HANDLE    WINAPI OpenSCManagerA(LPCSTR,LPCSTR,DWORD);
-HANDLE    WINAPI OpenSCManagerW(LPCWSTR,LPCWSTR,DWORD);
-#define     OpenSCManager WINELIB_NAME_AW(OpenSCManager)
-HANDLE    WINAPI OpenServiceA(HANDLE,LPCSTR,DWORD);
-HANDLE    WINAPI OpenServiceW(HANDLE,LPCWSTR,DWORD);
-#define     OpenService WINELIB_NAME_AW(OpenService)
-BOOL      WINAPI LookupPrivilegeValueA(LPCSTR,LPCSTR,LPVOID);
-BOOL      WINAPI LookupPrivilegeValueW(LPCWSTR,LPCWSTR,LPVOID);
-#define     LookupPrivilegeValue WINELIB_NAME_AW(LookupPrivilegeValue)
-HANDLE    WINAPI RegisterEventSourceA(LPCSTR,LPCSTR);
-HANDLE    WINAPI RegisterEventSourceW(LPCWSTR,LPCWSTR);
-#define     RegisterEventSource WINELIB_NAME_AW(RegisterEventSource)
 DWORD       WINAPI RegCreateKeyExA(HKEY,LPCSTR,DWORD,LPSTR,DWORD,REGSAM,
                                      LPSECURITY_ATTRIBUTES,LPHKEY,LPDWORD);
 DWORD       WINAPI RegCreateKeyExW(HKEY,LPCWSTR,DWORD,LPWSTR,DWORD,REGSAM,
@@ -134,17 +112,6 @@ LONG        WINAPI RegSaveKeyA(HKEY,LPCSTR,LPSECURITY_ATTRIBUTES);
 LONG        WINAPI RegSaveKeyW(HKEY,LPCWSTR,LPSECURITY_ATTRIBUTES);
 #define     RegSaveKey WINELIB_NAME_AW(RegSaveKey)
 LONG        WINAPI RegSetKeySecurity(HKEY,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
-BOOL      WINAPI CloseServiceHandle(HANDLE);
-BOOL      WINAPI ControlService(HANDLE,DWORD,LPSERVICE_STATUS);
-BOOL      WINAPI DeleteService(HANDLE);
-BOOL      WINAPI DeregisterEventSource(HANDLE);
-BOOL      WINAPI GetFileSecurityA(LPCSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,LPDWORD);
-BOOL      WINAPI GetFileSecurityW(LPCWSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,LPDWORD);
-#define     GetFileSecurity WINELIB_NAME_AW(GetFileSecurity)
-BOOL      WINAPI GetUserNameA(LPSTR,LPDWORD);
-BOOL      WINAPI GetUserNameW(LPWSTR,LPDWORD);
-#define     GetUserName WINELIB_NAME_AW(GetUserName)
-BOOL      WINAPI OpenProcessToken(HANDLE,DWORD,HANDLE*);
 LONG        WINAPI RegConnectRegistryA(LPCSTR,HKEY,LPHKEY);
 LONG        WINAPI RegConnectRegistryW(LPCWSTR,HKEY,LPHKEY);
 #define     RegConnectRegistry WINELIB_NAME_AW(RegConnectRegistry)
@@ -177,12 +144,6 @@ LONG        WINAPI RegRestoreKeyW(HKEY,LPCWSTR,DWORD);
 LONG        WINAPI RegUnLoadKeyA(HKEY,LPCSTR);
 LONG        WINAPI RegUnLoadKeyW(HKEY,LPCWSTR);
 #define     RegUnLoadKey WINELIB_NAME_AW(RegUnLoadKey)
-BOOL      WINAPI SetFileSecurityA(LPCSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
-BOOL      WINAPI SetFileSecurityW(LPCWSTR,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
-#define     SetFileSecurity WINELIB_NAME_AW(SetFileSecurity)
-BOOL      WINAPI StartServiceA(HANDLE,DWORD,LPCSTR*);
-BOOL      WINAPI StartServiceW(HANDLE,DWORD,LPCWSTR*);
-#define     StartService WINELIB_NAME_AW(StartService)
 
 /* Declarations for functions that are the same in Win16 and Win32 */
 
diff --git a/include/winsvc.h b/include/winsvc.h
new file mode 100644
index 00000000000..38bbda36ccd
--- /dev/null
+++ b/include/winsvc.h
@@ -0,0 +1,107 @@
+#ifndef __WINE_WINSVC_H
+#define __WINE_WINSVC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* defined(__cplusplus) */
+
+#include "windef.h"
+
+/* Handle types */
+
+typedef HANDLE SC_HANDLE, *LPSC_HANDLE;
+
+typedef DWORD SERVICE_STATUS_HANDLE;
+
+/* Service status structure */
+
+typedef struct _SERVICE_STATUS {
+  DWORD dwServiceType;
+  DWORD dwCurrentState;
+  DWORD dwControlsAccepted;
+  DWORD dwWin32ExitCode;
+  DWORD dwServiceSpecificExitCode;
+  DWORD dwCheckPoint;
+  DWORD dwWaitHint;
+} SERVICE_STATUS, *LPSERVICE_STATUS;
+
+/* Service main function prototype */
+
+typedef VOID (CALLBACK *LPSERVICE_MAIN_FUNCTIONA)(DWORD,LPSTR);
+typedef VOID (CALLBACK *LPSERVICE_MAIN_FUNCTIONW)(DWORD,LPWSTR);
+DECL_WINELIB_TYPE_AW(LPSERVICE_MAIN_FUNCTION)
+
+/* Service start table */
+
+typedef struct _SERVICE_TABLE_ENTRYA {
+    LPSTR                    lpServiceName;
+    LPSERVICE_MAIN_FUNCTIONA lpServiceProc;
+} SERVICE_TABLE_ENTRYA, *LPSERVICE_TABLE_ENTRYA;
+
+typedef struct _SERVICE_TABLE_ENTRYW {
+  LPWSTR                   lpServiceName;
+  LPSERVICE_MAIN_FUNCTIONW lpServiceProc;
+} SERVICE_TABLE_ENTRYW, *LPSERVICE_TABLE_ENTRYW;
+
+DECL_WINELIB_TYPE_AW(SERVICE_TABLE_ENTRY)
+DECL_WINELIB_TYPE_AW(LPSERVICE_TABLE_ENTRY)
+
+/* Service status enumeration structure */
+
+typedef struct _ENUM_SERVICE_STATUSA {
+  LPSTR          lpServiceName;
+  LPSTR          lpDisplayName;
+  SERVICE_STATUS ServiceStatus;
+} ENUM_SERVICE_STATUSA, *LPENUM_SERVICE_STATUSA;
+
+typedef struct _ENUM_SERVICE_STATUSW {
+    LPWSTR         lpServiceName;
+    LPWSTR         lpDisplayName;
+    SERVICE_STATUS ServiceStatus;
+} ENUM_SERVICE_STATUSW, *LPENUM_SERVICE_STATUSW;
+
+DECL_WINELIB_TYPE_AW(ENUM_SERVICE_STATUS)
+DECL_WINELIB_TYPE_AW(LPENUM_SERVICE_STATUS)
+
+/* Service control handler function prototype */
+
+typedef VOID (WINAPI *LPHANDLER_FUNCTION)(DWORD);
+
+/* API function prototypes */
+
+BOOL        WINAPI CloseServiceHandle(SC_HANDLE);
+BOOL        WINAPI ControlService(SC_HANDLE,DWORD,LPSERVICE_STATUS);
+SC_HANDLE   WINAPI CreateServiceA(DWORD,LPCSTR,LPCSTR,DWORD,DWORD,DWORD,DWORD,LPCSTR,
+                                  LPCSTR,LPDWORD,LPCSTR,LPCSTR,LPCSTR);
+SC_HANDLE   WINAPI CreateServiceW(DWORD,LPCWSTR,LPCWSTR,DWORD,DWORD,DWORD,DWORD,LPCWSTR,
+                                  LPCWSTR,LPDWORD,LPCWSTR,LPCWSTR,LPCWSTR);
+#define     CreateService WINELIB_NAME_AW(CreateService)
+BOOL        WINAPI DeleteService(SC_HANDLE);
+BOOL        WINAPI EnumServicesStatusA(SC_HANDLE,DWORD,DWORD,LPENUM_SERVICE_STATUSA,
+                                       DWORD,LPDWORD,LPDWORD,LPDWORD);
+BOOL        WINAPI EnumServicesStatusW(SC_HANDLE,DWORD,DWORD,LPENUM_SERVICE_STATUSW,
+                                       DWORD,LPDWORD,LPDWORD,LPDWORD);
+#define     EnumServicesStatus WINELIB_NAME_AW(EnumServicesStatus)
+SC_HANDLE   WINAPI OpenSCManagerA(LPCSTR,LPCSTR,DWORD);
+SC_HANDLE   WINAPI OpenSCManagerW(LPCWSTR,LPCWSTR,DWORD);
+#define     OpenSCManager WINELIB_NAME_AW(OpenSCManager)
+SC_HANDLE   WINAPI OpenServiceA(SC_HANDLE,LPCSTR,DWORD);
+SC_HANDLE   WINAPI OpenServiceW(SC_HANDLE,LPCWSTR,DWORD);
+#define     OpenService WINELIB_NAME_AW(OpenService)
+SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerA(LPCSTR,LPHANDLER_FUNCTION);
+SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerW(LPCWSTR,LPHANDLER_FUNCTION);
+#define     RegisterServiceCtrlHandler WINELIB_NAME_AW(RegisterServiceCtrlHandler)
+BOOL        WINAPI SetServiceStatus(SERVICE_STATUS_HANDLE,LPSERVICE_STATUS);
+BOOL        WINAPI StartServiceA(SC_HANDLE,DWORD,LPCSTR*);
+BOOL        WINAPI StartServiceW(SC_HANDLE,DWORD,LPCWSTR*);
+#define     StartService WINELIB_NAME_AW(StartService)
+BOOL        WINAPI StartServiceCtrlDispatcherA(LPSERVICE_TABLE_ENTRYA);
+BOOL        WINAPI StartServiceCtrlDispatcherW(LPSERVICE_TABLE_ENTRYW);
+#define     StartServiceCtrlDispatcher WINELIB_NAME_AW(StartServiceCtrlDispatcher)
+BOOL        WINAPI QueryServiceStatus(SC_HANDLE,LPSERVICE_STATUS);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* defined(__cplusplus) */
+
+#endif /* !defined(__WINE_WINSVC_H) */
diff --git a/include/wtypes.h b/include/wtypes.h
index da6b5894cae..b0a0ddbc9cd 100644
--- a/include/wtypes.h
+++ b/include/wtypes.h
@@ -218,7 +218,10 @@ typedef struct _ACL {
 } ACL, *PACL;
 
 typedef DWORD SECURITY_INFORMATION;
-typedef WORD SECURITY_DESCRIPTOR_CONTROL;
+typedef WORD SECURITY_DESCRIPTOR_CONTROL, *PSECURITY_DESCRIPTOR_CONTROL;
+typedef DWORD ACCESS_MASK, *PACCESS_MASK;
+
+typedef PVOID PGENERIC_MAPPING;
 
 /* The security descriptor structure */
 typedef struct {