is not easy to understand. In all other case, use the ntdll.dll
equivalent. */
-BOOL WINAPI
+BOOL
RevertToSelf ()
{
HANDLE tok = NULL;
DEFAULT_NTSTATUS_TO_BOOL_RETURN
}
-BOOL WINAPI
+BOOL
DuplicateTokenEx (HANDLE tok, DWORD access, LPSECURITY_ATTRIBUTES sec_attr,
SECURITY_IMPERSONATION_LEVEL level, TOKEN_TYPE type,
PHANDLE new_tok)
DEFAULT_NTSTATUS_TO_BOOL_RETURN
}
-BOOL WINAPI
+BOOL
ImpersonateLoggedOnUser (HANDLE tok)
{
NTSTATUS status;
DEFAULT_NTSTATUS_TO_BOOL_RETURN
}
-BOOL WINAPI
+BOOL
ImpersonateNamedPipeClient (HANDLE pipe)
{
IO_STATUS_BLOCK io;
}
}
-static DWORD WINAPI __attribute__ ((noreturn))
+static DWORD __attribute__ ((noreturn))
aiowaiter (void *unused)
{ /* One instance, called on its own cygthread; runs until program exits */
struct aiocb *aio;
}
/* Have to forward ref because of chicken v. egg situation */
-static DWORD WINAPI __attribute__ ((noreturn)) aioworker (void *);
+static DWORD __attribute__ ((noreturn)) aioworker (void *);
static void
aioinit (void)
return 0;
}
-static DWORD WINAPI __attribute__ ((noreturn))
+static DWORD __attribute__ ((noreturn))
aioworker (void *unused)
{ /* Multiple instances; called on own cygthreads; runs 'til program exits */
struct aiocb *aio;
/* Initial stub called by cygthread constructor. Performs initial
per-thread initialization and loops waiting for another thread function
to execute. */
-DWORD WINAPI
+DWORD
cygthread::stub (VOID *arg)
{
cygthread *info = (cygthread *) arg;
/* Overflow stub called by cygthread constructor. Calls specified function
and then exits the thread. */
-DWORD WINAPI
+DWORD
cygthread::simplestub (VOID *arg)
{
cygthread *info = (cygthread *) arg;
#ifndef _CYGTHREAD_H
#define _CYGTHREAD_H
-typedef void WINAPI (*LPVOID_THREAD_START_ROUTINE) (void *) __attribute__((noreturn)); // Input queue thread
+typedef void (*LPVOID_THREAD_START_ROUTINE) (void *) __attribute__((noreturn)); // Input queue thread
class cygthread
{
static void CALLBACK async_create (ULONG_PTR);
public:
bool terminate_thread ();
- static DWORD WINAPI stub (VOID *);
- static DWORD WINAPI simplestub (VOID *);
+ static DWORD stub (VOID *);
+ static DWORD simplestub (VOID *);
static DWORD main_thread_id;
static const char *name (DWORD = 0);
void callfunc (bool) __attribute__ ((noinline, ));
extern uint8_t _sigbe;
extern uint8_t _sigdelayed_end;
-static BOOL WINAPI ctrl_c_handler (DWORD);
+static BOOL ctrl_c_handler (DWORD);
static const struct
{
TODO: What we do here is to handle only __try/__except blocks in Cygwin.
"Normal" exceptions will simply exit the process. Still, better
than nothing... */
-LONG WINAPI
+LONG
myfault_altstack_handler (EXCEPTION_POINTERS *exc)
{
_cygtls& me = _my_tls;
}
/* Keyboard interrupt handler. */
-static BOOL WINAPI
+static BOOL
ctrl_c_handler (DWORD type)
{
static bool saw_close;
}
-DWORD WINAPI
+DWORD
dumpstack_overflow_wrapper (PVOID arg)
{
cygwin_exception *exc = (cygwin_exception *) arg;
api_fatal ("console device allocation failure - too many consoles in use, max consoles is 32");
}
-static DWORD WINAPI
+static DWORD
cons_master_thread (VOID *arg)
{
fhandler_console *fh = (fhandler_console *) arg;
DEF_HOOK (ContinueDebugEvent);
DEF_HOOK (GetProcAddress); /* Hooked for ConEmu cygwin connector */
-static BOOL WINAPI
+static BOOL
CreateProcessA_Hooked
(LPCSTR n, LPSTR c, LPSECURITY_ATTRIBUTES pa, LPSECURITY_ATTRIBUTES ta,
BOOL inh, DWORD f, LPVOID e, LPCSTR d,
return CreateProcessA_Orig (n, c, pa, ta, inh, f, e, d, si, pi);
}
-static BOOL WINAPI
+static BOOL
CreateProcessW_Hooked
(LPCWSTR n, LPWSTR c, LPSECURITY_ATTRIBUTES pa, LPSECURITY_ATTRIBUTES ta,
BOOL inh, DWORD f, LPVOID e, LPCWSTR d,
return CreateProcessW_Orig (n, c, pa, ta, inh, f, e, d, si, pi);
}
-static BOOL WINAPI
+static BOOL
ContinueDebugEvent_Hooked
(DWORD p, DWORD t, DWORD s)
{
}
/* Hooked for ConEmu cygwin connector */
-static FARPROC WINAPI
+static FARPROC
GetProcAddress_Hooked (HMODULE h, LPCSTR n)
{
if (strcmp(n, "RequestTermConnector") == 0)
return 0;
}
-static DWORD WINAPI
+static DWORD
fifo_reader_thread (LPVOID param)
{
fhandler_fifo *fh = (fhandler_fifo *) param;
debug_printf ("WNetGetLastError failed: %u", gle_ret);
}
-static DWORD WINAPI
+static DWORD
thread_netdrive (void *arg)
{
netdriveinf *ndi = (netdriveinf *) arg;
};
/* Just hop to the wait_pipe_thread method. */
-DWORD WINAPI
+DWORD
connect_wait_func (LPVOID param)
{
conn_wait_info_t *wait_info = (conn_wait_info_t *) param;
DEF_HOOK (CreateProcessA);
DEF_HOOK (CreateProcessW);
-static BOOL WINAPI
+static BOOL
CreateProcessA_Hooked
(LPCSTR n, LPSTR c, LPSECURITY_ATTRIBUTES pa, LPSECURITY_ATTRIBUTES ta,
BOOL inh, DWORD f, LPVOID e, LPCSTR d,
return ret;
}
-static BOOL WINAPI
+static BOOL
CreateProcessW_Hooked
(LPCWSTR n, LPWSTR c, LPSECURITY_ATTRIBUTES pa, LPSECURITY_ATTRIBUTES ta,
BOOL inh, DWORD f, LPVOID e, LPCWSTR d,
return 0;
}
-static DWORD WINAPI
+static DWORD
pty_master_thread (VOID *arg)
{
fhandler_pty_master::master_thread_param_t p;
return 0;
}
-static DWORD WINAPI
+static DWORD
pty_master_fwd_thread (VOID *arg)
{
fhandler_pty_master::master_fwd_thread_param_t p;
return &attr->attr;
}
-DWORD WINAPI
+DWORD
create_lock_in_parent (PVOID param)
{
HANDLE lf_obj;
return 1;
}
-DWORD WINAPI
+DWORD
delete_lock_in_parent (PVOID param)
{
inode_t *node, *next_node;
NTSTATUS status;
};
-static DWORD WINAPI
+static DWORD
blocking_lock_thr (LPVOID param)
{
struct lock_parms *lp = (struct lock_parms *) param;
#define DECLARE_CYGWIN_DLL(Entry) \
\
CDECL_BEGIN \
- int WINAPI Entry (HINSTANCE h, DWORD reason, void *ptr); \
+ int Entry (HINSTANCE h, DWORD reason, void *ptr); \
typedef int (*mainfunc) (int, char **, char **); \
extern PVOID cygwin_attach_dll (HMODULE, mainfunc); \
extern void cygwin_detach_dll (PVOID); \
\
static PVOID dll_index; \
\
-int WINAPI _cygwin_dll_entry (HINSTANCE h, DWORD reason, void *ptr) \
+int _cygwin_dll_entry (HINSTANCE h, DWORD reason, void *ptr) \
{ \
int ret; \
ret = 1; \
static bool dll_finished_loading;
#define OLDFUNC_OFFSET -1
-static void WINAPI
+static void
threadfunc_fe (VOID *arg)
{
_cygtls::call ((DWORD (*) (void *, void *)) TlsGetValue (_my_oldfunc), arg);
need the alloca'd space in the DLL_PROCESS_ATTACH case below... */
void *alloca_dummy;
-extern "C" BOOL WINAPI
+extern "C" BOOL
dll_entry (HANDLE h, DWORD reason, void *static_load)
{
BOOL test_stack_marker;
/* Implement CreateEvent/OpenEvent so that named objects are always created in
Cygwin shared object namespace. */
-HANDLE WINAPI
+HANDLE
CreateEventW (LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset,
BOOL bInitialState, LPCWSTR lpName)
{
return evt;
}
-HANDLE WINAPI
+HANDLE
CreateEventA (LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset,
BOOL bInitialState, LPCSTR lpName)
{
lpName ? name : NULL);
}
-HANDLE WINAPI
+HANDLE
OpenEventW (DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName)
{
HANDLE evt;
return evt;
}
-HANDLE WINAPI
+HANDLE
OpenEventA (DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName)
{
WCHAR name[MAX_PATH];
/* Implement CreateMutex/OpenMutex so that named objects are always created in
Cygwin shared object namespace. */
-HANDLE WINAPI
+HANDLE
CreateMutexW (LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner,
LPCWSTR lpName)
{
return mtx;
}
-HANDLE WINAPI
+HANDLE
CreateMutexA (LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner,
LPCSTR lpName)
{
return CreateMutexW (lpMutexAttributes, bInitialOwner, lpName ? name : NULL);
}
-HANDLE WINAPI
+HANDLE
OpenMutexW (DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName)
{
HANDLE mtx;
return mtx;
}
-HANDLE WINAPI
+HANDLE
OpenMutexA (DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName)
{
WCHAR name[MAX_PATH];
/* Implement CreateSemaphore/OpenSemaphore so that named objects are always
created in Cygwin shared object namespace. */
-HANDLE WINAPI
+HANDLE
CreateSemaphoreW (LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
LONG lInitialCount, LONG lMaximumCount, LPCWSTR lpName)
{
return sem;
}
-HANDLE WINAPI
+HANDLE
CreateSemaphoreA (LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
LONG lInitialCount, LONG lMaximumCount, LPCSTR lpName)
{
lpName ? name : NULL);
}
-HANDLE WINAPI
+HANDLE
OpenSemaphoreW (DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName)
{
HANDLE sem;
return sem;
}
-HANDLE WINAPI
+HANDLE
OpenSemaphoreA (DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName)
{
WCHAR name[MAX_PATH];
/* Implement CreateFileMapping/OpenFileMapping so that named objects are always
created in Cygwin shared object namespace. */
-HANDLE WINAPI
+HANDLE
CreateFileMappingW (HANDLE hFile, LPSECURITY_ATTRIBUTES lpAttributes,
DWORD flProtect, DWORD dwMaximumSizeHigh,
DWORD dwMaximumSizeLow, LPCWSTR lpName)
return sect;
}
-HANDLE WINAPI
+HANDLE
CreateFileMappingA (HANDLE hFile, LPSECURITY_ATTRIBUTES lpAttributes,
DWORD flProtect, DWORD dwMaximumSizeHigh,
DWORD dwMaximumSizeLow, LPCSTR lpName)
dwMaximumSizeLow, lpName ? name : NULL);
}
-HANDLE WINAPI
+HANDLE
OpenFileMappingW (DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName)
{
HANDLE sect;
return sect;
}
-HANDLE WINAPI
+HANDLE
OpenFileMappingA (DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName)
{
WCHAR name[MAX_PATH];
/* Cygwin replacement for GetCommandLineW. Returns a concatenated wide string
representing the argv list, constructed using roughly the same mechanism as
child_info_spawn::worker */
-extern "C" LPWSTR WINAPI
+extern "C" LPWSTR
cygwin_GetCommandLineW (void)
{
return ucmd ()->Buffer;
/* Cygwin replacement for GetCommandLineA. Returns a concatenated string
representing the argv list, constructed using roughly the same mechanism
as child_info_spawn::worker */
-extern "C" LPSTR WINAPI
+extern "C" LPSTR
cygwin_GetCommandLineA (void)
{
static ANSI_STRING cmd;
return ret;
}
-static DWORD WINAPI
+static DWORD
ldap_init_thr (LPVOID param)
{
cyg_ldap_init *cl = (cyg_ldap_init *) param;
return ret;
}
-static DWORD WINAPI
+static DWORD
ldap_search_thr (LPVOID param)
{
cyg_ldap_search *cl = (cyg_ldap_search *) param;
return ret;
}
-static DWORD WINAPI
+static DWORD
ldap_next_page_thr (LPVOID param)
{
cyg_ldap_next_page *cl = (cyg_ldap_next_page *) param;
#include "mmap_alloc.h"
/* not yet prototyped in w32api */
-extern "C" HRESULT WINAPI SetThreadDescription (HANDLE hThread, PCWSTR lpThreadDescription);
+extern "C" HRESULT SetThreadDescription (HANDLE hThread, PCWSTR lpThreadDescription);
/* Get handle count of an object. */
ULONG
/* Minimal overlapped pipe I/O implementation for signal and commune stuff. */
-BOOL WINAPI
+BOOL
CreatePipeOverlapped (PHANDLE hr, PHANDLE hw, LPSECURITY_ATTRIBUTES sa)
{
int ret = fhandler_pipe::create (sa, hr, hw, 0, NULL,
return ret == 0;
}
-BOOL WINAPI
+BOOL
ReadPipeOverlapped (HANDLE h, PVOID buf, DWORD len, LPDWORD ret_len,
DWORD timeout)
{
return ret;
}
-BOOL WINAPI
+BOOL
WritePipeOverlapped (HANDLE h, LPCVOID buf, DWORD len, LPDWORD ret_len,
DWORD timeout)
{
ULONG guardsize;
};
-DWORD WINAPI
+DWORD
pthread_wrapper (PVOID arg)
{
/* Just plain paranoia. */
return ((PBYTE) allocationbase + stacksize - 16);
}
-HANDLE WINAPI
+HANDLE
CygwinCreateThread (LPTHREAD_START_ROUTINE thread_func, PVOID thread_arg,
PVOID stackaddr, ULONG stacksize, ULONG guardsize,
DWORD creation_flags, LPDWORD thread_id)
bool create_pipe (PHANDLE, PHANDLE, LPSECURITY_ATTRIBUTES, DWORD);
-BOOL WINAPI CreatePipeOverlapped (PHANDLE read_handle, PHANDLE write_handle,
- LPSECURITY_ATTRIBUTES sa);
-BOOL WINAPI ReadPipeOverlapped (HANDLE h, PVOID buf, DWORD len,
- LPDWORD ret_len, DWORD timeout);
-BOOL WINAPI WritePipeOverlapped (HANDLE h, LPCVOID buf, DWORD len,
- LPDWORD ret_len, DWORD timeout);
+BOOL CreatePipeOverlapped (PHANDLE read_handle, PHANDLE write_handle,
+ LPSECURITY_ATTRIBUTES sa);
+BOOL ReadPipeOverlapped (HANDLE h, PVOID buf, DWORD len,
+ LPDWORD ret_len, DWORD timeout);
+BOOL WritePipeOverlapped (HANDLE h, LPCVOID buf, DWORD len,
+ LPDWORD ret_len, DWORD timeout);
/* class for per-line reading using native functions. The caller provides
the file as an POBJECT_ATTRIBUTES, and the buffer space. */
extern PVOID create_new_main_thread_stack (PVOID &allocationbase);
-extern "C" DWORD WINAPI pthread_wrapper (PVOID arg);
-extern "C" HANDLE WINAPI CygwinCreateThread (LPTHREAD_START_ROUTINE thread_func,
- PVOID thread_arg, PVOID stackaddr,
- ULONG stacksize, ULONG guardsize,
- DWORD creation_flags,
- LPDWORD thread_id);
+extern "C" DWORD pthread_wrapper (PVOID arg);
+extern "C" HANDLE CygwinCreateThread (LPTHREAD_START_ROUTINE thread_func,
+ PVOID thread_arg, PVOID stackaddr,
+ ULONG stacksize, ULONG guardsize,
+ DWORD creation_flags, LPDWORD thread_id);
void SetThreadName (DWORD dwThreadID, const char* threadName);
PVOID, ULONG, PULONG);
NTSTATUS NTAPI NtQuerySystemInformation (SYSTEM_INFORMATION_CLASS,
PVOID, ULONG, PULONG);
- NTSTATUS WINAPI NtQuerySystemTime (PLARGE_INTEGER);
+ NTSTATUS NTAPI NtQuerySystemTime (PLARGE_INTEGER);
NTSTATUS NTAPI NtQuerySecurityObject (HANDLE, SECURITY_INFORMATION,
PSECURITY_DESCRIPTOR, ULONG, PULONG);
NTSTATUS NTAPI NtQuerySymbolicLinkObject (HANDLE, PUNICODE_STRING, PULONG);
return !!h;
}
-DWORD WINAPI
+DWORD
commune_process (void *arg)
{
siginfo_t& si = *((siginfo_t *) arg);
is received on the pipe, it is assumed that the cygwin pid has exited.
Otherwise, various "signals" can be sent to the parent to inform the
parent to perform a certain action. */
-static DWORD WINAPI
+static DWORD
proc_waiter (void *arg)
{
pinfo vchild = *(pinfo *) arg;
friend class pinfo_minimal;
};
-DWORD WINAPI commune_process (void *);
+DWORD commune_process (void *);
enum parent_alerter
{
return 0;
}
-static DWORD WINAPI
+static DWORD
timer_thread (VOID *x)
{
timer_tracker *tt = ((timer_tracker *) x);
return -1;
}
- p->profthr = CreateThread (0, 0, (DWORD (WINAPI *)(LPVOID)) profthr_func,
+ p->profthr = CreateThread (0, 0, (DWORD (*)(LPVOID)) profthr_func,
(void *) p, 0, &thrid);
if (!p->profthr)
static int start_thread_pipe (select_record *me, select_stuff *stuff);
-static DWORD WINAPI
+static DWORD
thread_pipe (void *arg)
{
select_pipe_info *pi = (select_pipe_info *) arg;
static int start_thread_fifo (select_record *me, select_stuff *stuff);
-static DWORD WINAPI
+static DWORD
thread_fifo (void *arg)
{
select_fifo_info *pi = (select_fifo_info *) arg;
static int console_startup (select_record *me, select_stuff *stuff);
-static DWORD WINAPI
+static DWORD
thread_console (void *arg)
{
select_console_info *ci = (select_console_info *) arg;
static int pty_slave_startup (select_record *me, select_stuff *stuff);
-static DWORD WINAPI
+static DWORD
thread_pty_slave (void *arg)
{
select_pipe_info *pi = (select_pipe_info *) arg;
static int start_thread_socket (select_record *, select_stuff *);
-static DWORD WINAPI
+static DWORD
thread_socket (void *arg)
{
select_socket_info *si = (select_socket_info *) arg;
static __inline__ bool get_proc_lock (DWORD, DWORD);
static int remove_proc (int);
static bool stopped_or_terminated (waitq *, _pinfo *);
-static void WINAPI wait_sig (VOID *arg);
+static void wait_sig (VOID *arg);
/* wait_sig bookkeeping */
void clear (int sig) {sigs[sig].si.si_signo = 0;}
void clear (_cygtls *tls);
friend void sig_dispatch_pending (bool);
- friend void WINAPI wait_sig (VOID *arg);
+ friend void wait_sig (VOID *arg);
};
Static pending_signals sigq;
/* Process signals by waiting for signal data to arrive in a pipe.
Set a completion event if one was specified. */
-static void WINAPI
+static void
wait_sig (VOID *)
{
_sig_tls = &_my_tls;
return result;
}
-DWORD WINAPI
+DWORD
pthread::thread_init_wrapper (void *arg)
{
exception protect;
virtual void pop_cleanup_handler (int const execute);
static pthread* self ();
- static DWORD WINAPI thread_init_wrapper (void *);
+ static DWORD thread_init_wrapper (void *);
virtual unsigned long getsequence_np();
return 0;
}
-static DWORD WINAPI
+static DWORD
timerfd_thread (VOID *arg)
{
timerfd_tracker *tt = ((timerfd_tracker *) arg);
}
/* Handle windows events. Inherits ownership of the wininfo lock */
-DWORD WINAPI
+DWORD
wininfo::winthread ()
{
MSG msg;
return 0;
}
-static DWORD WINAPI
+static DWORD
winthread (VOID *arg)
{
return ((wininfo *) arg)->winthread ();
int process (HWND, UINT, WPARAM, LPARAM);
void lock ();
void release ();
- DWORD WINAPI winthread ();
+ DWORD winthread ();
};
extern wininfo winmsg;
git://sourceware.org / newlib-cygwin.git / commitdiff