2009-12-18 Corinna Vinschen <corinna@vinschen.de>
+ Throughout, replace hMainProc with GetCurrentProcess/NtCurrentProcess
+ according to context. Throughout, replace hMainThread with
+ GetCurrentThread/NtCurrentThread according to context.
+ * dcrt0.cc (dll_crt0_0): Drop duplication of GetCurrentProcess to
+ hMainProc. Drop duplication of GetCurrentThread to hMainThread.
+ * dtable.cc (dtable::stdio_init): Remove useless comment.
+ * globals.cc (hMainProc): Remove.
+ (hMainThread): Remove.
+ * ntdll.h (NtCurrentProcess): Define.
+ (NtCurrentThread: Define.
+
+2009-12-18 Corinna Vinschen <corinna@vinschen.de>
+
* fhandler.h (fhandler_registry::value_name): Convert to wchar_t*.
* fhandler_registry.cc: Call UNICODE registry functions throughout
and convert to multibyte using current locale's charset. Accommodate
cygheap_fixup_in_child (true);
memory_init (false);
if (!moreinfo->myself_pinfo ||
- !DuplicateHandle (hMainProc, moreinfo->myself_pinfo, hMainProc, &h, 0,
+ !DuplicateHandle (GetCurrentProcess (), moreinfo->myself_pinfo,
+ GetCurrentProcess (), &h, 0,
FALSE, DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE))
h = NULL;
myself.thisproc (h);
}
if (dep_system_policy < OptIn)
return;
- if (!GetProcessDEPPolicy (hMainProc, &ppolicy, &perm))
+ if (!GetProcessDEPPolicy (GetCurrentProcess (), &ppolicy, &perm))
{
debug_printf ("GetProcessDEPPolicy: %E");
return;
user_data->impure_ptr = _impure_ptr;
user_data->impure_ptr_ptr = &_impure_ptr;
- if (!DuplicateHandle (GetCurrentProcess (), GetCurrentProcess (),
- GetCurrentProcess (), &hMainProc, 0, FALSE,
- DUPLICATE_SAME_ACCESS))
- hMainProc = GetCurrentProcess ();
-
- DuplicateHandle (hMainProc, GetCurrentThread (), hMainProc,
- &hMainThread, 0, false, DUPLICATE_SAME_ACCESS);
-
- OpenProcessToken (hMainProc, MAXIMUM_ALLOWED, &hProcToken);
+ OpenProcessToken (GetCurrentProcess (), MAXIMUM_ALLOWED, &hProcToken);
set_cygwin_privileges (hProcToken);
device::init ();
small_printf ("cmalloc returns %p\n", cmalloc (HEAP_STR, n));
#endif
- ProtectHandle (hMainProc);
- ProtectHandle (hMainThread);
-
cygheap->cwd.init ();
/* Initialize pthread mainthread when not forked and it is safe to call new,
{
/* Since this code is not invoked for forked tasks, we don't have
to worry about the close-on-exec flag here. */
- /* CV 2009-11-26: Using hMainProc results in ERROR_INVALID_PARAMETER
- when trying to duplicate a console handle. It only works using
- the GetCurrentProcess () pseudo handle for some unknown reason. */
if (!DuplicateHandle (GetCurrentProcess (), out,
GetCurrentProcess (), &err,
0, TRUE, DUPLICATE_SAME_ACCESS))
if (debugging && ++debugging < 500000)
{
- SetThreadPriority (hMainThread, THREAD_PRIORITY_NORMAL);
+ SetThreadPriority (GetCurrentThread (), THREAD_PRIORITY_NORMAL);
return 0;
}
{
CONTEXT c;
c.ContextFlags = CONTEXT_FULL;
- GetThreadContext (hMainThread, &c);
+ GetThreadContext (GetCurrentThread (), &c);
use_tls->copy_context (&c);
si.si_signo |= 0x80;
}
HANDLE nh;
if (!nohandle ())
{
- if (!DuplicateHandle (hMainProc, get_handle (), hMainProc, &nh, 0, TRUE,
- DUPLICATE_SAME_ACCESS))
+ if (!DuplicateHandle (GetCurrentProcess (), get_handle (),
+ GetCurrentProcess (), &nh,
+ 0, TRUE, DUPLICATE_SAME_ACCESS))
{
debug_printf ("dup(%s) failed, handle %x, %E",
get_name (), get_handle ());
bool res = false;
if (/* !is_socket () && */ !close_on_exec ())
debug_printf ("handle %p already opened", h);
- else if (!DuplicateHandle (parent, h, hMainProc, &h, 0, !close_on_exec (),
- DUPLICATE_SAME_ACCESS))
+ else if (!DuplicateHandle (parent, h, GetCurrentProcess (), &h,
+ 0, !close_on_exec (), DUPLICATE_SAME_ACCESS))
system_printf ("%s - %E, handle %s<%p>", get_name (), name, h);
else
{
fhandler_fifo *fifo_child = (fhandler_fifo *) child;
if (res == 0 && dummy_client)
{
- bool dres = DuplicateHandle (hMainProc, dummy_client, hMainProc,
+ bool dres = DuplicateHandle (GetCurrentProcess (), dummy_client,
+ GetCurrentProcess (),
&fifo_child->dummy_client, 0,
TRUE, DUPLICATE_SAME_ACCESS);
if (!dres)
debug_printf ("here");
fhandler_socket *fhs = (fhandler_socket *) child;
- if (!DuplicateHandle (hMainProc, wsock_mtx, hMainProc, &fhs->wsock_mtx, 0,
- TRUE, DUPLICATE_SAME_ACCESS))
+ if (!DuplicateHandle (GetCurrentProcess (), wsock_mtx,
+ GetCurrentProcess (), &fhs->wsock_mtx,
+ 0, TRUE, DUPLICATE_SAME_ACCESS))
{
__seterrno ();
return -1;
}
- if (!DuplicateHandle (hMainProc, wsock_evt, hMainProc, &fhs->wsock_evt, 0,
- TRUE, DUPLICATE_SAME_ACCESS))
+ if (!DuplicateHandle (GetCurrentProcess (), wsock_evt,
+ GetCurrentProcess (), &fhs->wsock_evt,
+ 0, TRUE, DUPLICATE_SAME_ACCESS))
{
__seterrno ();
NtClose (fhs->wsock_mtx);
if (!fhs->fixup_before_fork_exec (GetCurrentProcessId ()))
{
cygheap->user.reimpersonate ();
- fhs->fixup_after_fork (hMainProc);
+ fhs->fixup_after_fork (GetCurrentProcess ());
if (fhs->get_io_handle() != (HANDLE) INVALID_SOCKET)
return 0;
}
{
lock (-1);
fhandler_dev_tape *fh = (fhandler_dev_tape *) child;
- if (!DuplicateHandle (hMainProc, mt_mtx, hMainProc, &fh->mt_mtx, 0, TRUE,
- DUPLICATE_SAME_ACCESS))
+ if (!DuplicateHandle (GetCurrentProcess (), mt_mtx,
+ GetCurrentProcess (), &fh->mt_mtx,
+ 0, TRUE, DUPLICATE_SAME_ACCESS))
{
debug_printf ("dup(%s) failed, mutex handle %x, %E",
get_name (), mt_mtx);
}
fh->mt_evt = NULL;
if (mt_evt &&
- !DuplicateHandle (hMainProc, mt_evt, hMainProc, &fh->mt_evt, 0, TRUE,
- DUPLICATE_SAME_ACCESS))
+ !DuplicateHandle (GetCurrentProcess (), mt_evt,
+ GetCurrentProcess (), &fh->mt_evt,
+ 0, TRUE, DUPLICATE_SAME_ACCESS))
{
debug_printf ("dup(%s) failed, event handle %x, %E",
get_name (), mt_evt);
}
if (!DuplicateHandle (tty_owner, get_ttyp ()->from_master,
- hMainProc, &from_master_local, 0, TRUE,
+ GetCurrentProcess (), &from_master_local, 0, TRUE,
DUPLICATE_SAME_ACCESS))
{
termios_printf ("can't duplicate input from %u/%p, %E",
VerifyHandle (from_master_local);
if (!DuplicateHandle (tty_owner, get_ttyp ()->to_master,
- hMainProc, &to_master_local, 0, TRUE,
+ GetCurrentProcess (), &to_master_local, 0, TRUE,
DUPLICATE_SAME_ACCESS))
{
termios_printf ("can't duplicate output, %E");
if (arch->dwProcessId != wpid)
{
tty& t = *get_ttyp ();
- if (!DuplicateHandle (parent, arch->from_master, hMainProc,
+ if (!DuplicateHandle (parent, arch->from_master, GetCurrentProcess (),
&arch->from_master, 0, false, DUPLICATE_SAME_ACCESS))
system_printf ("couldn't duplicate from_parent(%p), %E", arch->from_master);
- if (!DuplicateHandle (parent, arch->to_master, hMainProc,
+ if (!DuplicateHandle (parent, arch->to_master, GetCurrentProcess (),
&arch->to_master, 0, false, DUPLICATE_SAME_ACCESS))
system_printf ("couldn't duplicate to_parent(%p), %E", arch->from_master);
if (myself->pid == t.master_pid)
to avoid having to alloc 64K from the stack. */
tmp_pathbuf tp;
PSECURITY_DESCRIPTOR sd = (PSECURITY_DESCRIPTOR) tp.w_get ();
- status = NtQuerySecurityObject (hMainProc, DACL_SECURITY_INFORMATION, sd,
+ status = NtQuerySecurityObject (NtCurrentProcess (),
+ DACL_SECURITY_INFORMATION, sd,
NT_MAX_PATH * sizeof (WCHAR), &len);
if (!NT_SUCCESS (status))
{
}
dacl->AclSize = (char *) ace - (char *) dacl;
/* Write the DACL back. */
- status = NtSetSecurityObject (hMainProc, DACL_SECURITY_INFORMATION, sd);
+ status = NtSetSecurityObject (NtCurrentProcess (), DACL_SECURITY_INFORMATION, sd);
if (!NT_SUCCESS (status))
{
debug_printf ("NtSetSecurityObject: %p", status);
windows from reusing the same pid. */
if (last_fork_procs[nfork_procs])
ForceCloseHandle1 (last_fork_procs[nfork_procs], fork_stupidity);
- if (DuplicateHandle (hMainProc, h, hMainProc, &last_fork_procs[nfork_procs],
- 0, FALSE, DUPLICATE_SAME_ACCESS))
+ if (DuplicateHandle (GetCurrentProcess (), h,
+ GetCurrentProcess (), &last_fork_procs[nfork_procs],
+ 0, FALSE, DUPLICATE_SAME_ACCESS))
ProtectHandle1 (last_fork_procs[nfork_procs], fork_stupidity);
else
{
pinfo child;
static char errbuf[256];
- int c_flags = GetPriorityClass (hMainProc);
+ int c_flags = GetPriorityClass (GetCurrentProcess ());
debug_printf ("priority class %d", c_flags);
/* If we don't have a console, then don't create a console for the
#include <malloc.h>
#include <cygwin/version.h>
-HANDLE NO_COPY hMainProc = (HANDLE) -1;
-HANDLE NO_COPY hMainThread;
HANDLE NO_COPY hProcToken;
HANDLE NO_COPY hProcImpToken;
HMODULE NO_COPY cygwin_hmodule;
/* Unfortunately there's no simpler way to retrieve the
parent process in NT, as far as I know. Hints welcome. */
- ret = NtQueryInformationProcess (GetCurrentProcess (),
+ ret = NtQueryInformationProcess (NtCurrentProcess (),
ProcessBasicInformation,
&pbi, sizeof pbi, NULL);
if (NT_SUCCESS (ret)
if (GetCurrentThreadId () == cygthread::main_thread_id)
new_prio = THREAD_PRIORITY_LOWEST;
else
- new_prio = GetThreadPriority (hMainThread);
+ new_prio = GetThreadPriority (GetCurrentThread ());
if (curr_prio != new_prio)
/* Force any threads in normal priority to be scheduled */
Note: Retrying the mapping might be unnecessary, now that mmap64 checks
for a valid memory area first. */
- ret = NtMapViewOfSection (h, GetCurrentProcess (), &base, 0, commitsize,
+ ret = NtMapViewOfSection (h, NtCurrentProcess (), &base, 0, commitsize,
&offset, &viewsize, ViewShare, alloc_type, protect);
if (!NT_SUCCESS (ret) && addr && !fixed (flags))
{
base = NULL;
- ret = NtMapViewOfSection (h, GetCurrentProcess (), &base, 0, commitsize,
+ ret = NtMapViewOfSection (h, NtCurrentProcess (), &base, 0, commitsize,
&offset, &viewsize, ViewShare, 0, protect);
}
if (!NT_SUCCESS (ret))
NTSTATUS status = 0;
do
{
- status = NtLockVirtualMemory (hMainProc, &base, &size, LOCK_VM_IN_RAM);
+ status = NtLockVirtualMemory (NtCurrentProcess (), &base, &size,
+ LOCK_VM_IN_RAM);
if (status == STATUS_WORKING_SET_QUOTA)
{
/* The working set is too small, try to increase it so that the
further, or until NtLockVirtualMemory returns successfully (or
with another error). */
ULONG min, max;
- if (!GetProcessWorkingSetSize (hMainProc, &min, &max))
+ if (!GetProcessWorkingSetSize (GetCurrentProcess (), &min, &max))
{
set_errno (ENOMEM);
break;
min += pagesize;
if (max < min)
max = min;
- if (!SetProcessWorkingSetSize (hMainProc, min, max))
+ if (!SetProcessWorkingSetSize (GetCurrentProcess (), min, max))
{
set_errno (ENOMEM);
break;
size_t pagesize = getpagesize ();
PVOID base = (PVOID) rounddown((uintptr_t) addr, pagesize);
ULONG size = roundup2 (((uintptr_t) addr - (uintptr_t) base) + len, pagesize);
- NTSTATUS status = NtUnlockVirtualMemory (hMainProc, &base, &size,
+ NTSTATUS status = NtUnlockVirtualMemory (NtCurrentProcess (), &base, &size,
LOCK_VM_IN_RAM);
if (!NT_SUCCESS (status))
__seterrno_from_nt_status (status);
__seterrno ();
else
{
- NtUnmapViewOfSection (GetCurrentProcess (), base);
+ NtUnmapViewOfSection (NtCurrentProcess (), base);
set_errno (EINVAL);
debug_printf ("MapView: address shift with MAP_FIXED given");
}
VirtualFree (addr, 0, MEM_RELEASE);
else
{
- NtUnmapViewOfSection (GetCurrentProcess (), addr);
+ NtUnmapViewOfSection (NtCurrentProcess (), addr);
NtClose (h);
}
return 0;
__seterrno ();
else
{
- NtUnmapViewOfSection (GetCurrentProcess (), base);
+ NtUnmapViewOfSection (NtCurrentProcess (), base);
set_errno (EINVAL);
debug_printf ("MapView: address shift with MAP_FIXED given");
}
int
fhandler_disk_file::munmap (HANDLE h, caddr_t addr, size_t len)
{
- NtUnmapViewOfSection (GetCurrentProcess (), addr);
+ NtUnmapViewOfSection (NtCurrentProcess (), addr);
NtClose (h);
return 0;
}
__seterrno ();
else
{
- NtUnmapViewOfSection (GetCurrentProcess (), base);
+ NtUnmapViewOfSection (NtCurrentProcess (), base);
set_errno (EINVAL);
debug_printf ("MapView: address shift with MAP_FIXED given");
}
fhandler_dev_mem::munmap (HANDLE h, caddr_t addr, size_t len)
{
NTSTATUS ret;
- if (!NT_SUCCESS (ret = NtUnmapViewOfSection (GetCurrentProcess (), addr)))
+ if (!NT_SUCCESS (ret = NtUnmapViewOfSection (NtCurrentProcess (), addr)))
{
__seterrno_from_nt_status (ret);
return -1;
/* Function declarations for ntdll.dll. These don't appear in any
standard Win32 header. */
+
+#define NtCurrentProcess() ((HANDLE) 0xffffffff)
+#define NtCurrentThread() ((HANDLE) 0xfffffffe)
+
extern "C"
{
NTSTATUS NTAPI NtAdjustPrivilegesToken (HANDLE, BOOLEAN, PTOKEN_PRIVILEGES,
myself->uid = ILLEGAL_UID;
myself->gid = UNKNOWN_GID;
environ_init (NULL, 0); /* call after myself has been set up */
- myself->nice = winprio_to_nice (GetPriorityClass (hMainProc));
+ myself->nice = winprio_to_nice (GetPriorityClass (GetCurrentProcess ()));
debug_printf ("Set nice to %d", myself->nice);
}
/* FIXME: There is a potential race between an execed process and its
parent here. I hated to add a mutex just for that, though. */
struct rusage r;
- fill_rusage (&r, hMainProc);
+ fill_rusage (&r, GetCurrentProcess ());
add_rusage (&self->rusage_self, &r);
int exitcode = self->exitcode & 0xffff;
if (!self->cygstarted)
parent sees it. */
if (this != myself || is_toplevel_proc)
flags |= DUPLICATE_CLOSE_SOURCE;
- bool res = DuplicateHandle (hMainProc, wr_proc_pipe, hProcess, &wr_proc_pipe,
- 0, FALSE, flags);
+ bool res = DuplicateHandle (GetCurrentProcess (), wr_proc_pipe,
+ hProcess, &wr_proc_pipe, 0, FALSE, flags);
if (!res && WaitForSingleObject (hProcess, 0) != WAIT_OBJECT_0)
{
wr_proc_pipe = orig_wr_proc_pipe;
goto out;
}
inh = !(flags & O_NOINHERIT);
- if (!DuplicateHandle (proc, pipe_hdl, hMainProc, &nio_hdl,
+ if (!DuplicateHandle (proc, pipe_hdl, GetCurrentProcess (), &nio_hdl,
0, inh, DUPLICATE_SAME_ACCESS))
{
__seterrno ();
if (intwho == RUSAGE_SELF)
{
memset (&r, 0, sizeof (r));
- fill_rusage (&r, hMainProc);
+ fill_rusage (&r, GetCurrentProcess ());
*rusage_in = r;
}
else if (intwho == RUSAGE_CHILDREN)
if (!dir)
{
PROCESS_SESSION_INFORMATION psi;
- status = NtQueryInformationProcess (GetCurrentProcess (),
+ status = NtQueryInformationProcess (NtCurrentProcess (),
ProcessSessionInformation,
&psi, sizeof psi, NULL);
if (!NT_SUCCESS (status) || psi.SessionId == 0)
NTSTATUS status;
vm_object_t ptr = sph_entry->ptr;
ULONG viewsize = sph_entry->parent->size;
- status = NtMapViewOfSection (sph_entry->parent->hdl, GetCurrentProcess (),
+ status = NtMapViewOfSection (sph_entry->parent->hdl, NtCurrentProcess (),
&ptr, 0, sph_entry->parent->size, NULL,
&viewsize, ViewShare, 0, sph_entry->access);
if (!NT_SUCCESS (status) || ptr != sph_entry->ptr)
vm_object_t ptr = NULL;
ULONG viewsize = ssh_entry->size;
ULONG access = (shmflg & SHM_RDONLY) ? PAGE_READONLY : PAGE_READWRITE;
- status = NtMapViewOfSection (ssh_entry->hdl, GetCurrentProcess (), &ptr, 0,
+ status = NtMapViewOfSection (ssh_entry->hdl, NtCurrentProcess (), &ptr, 0,
ssh_entry->size, NULL, &viewsize, ViewShare,
MEM_TOP_DOWN, access);
if (!NT_SUCCESS (status))
goto out;
}
VerifyHandle (hp);
- if (!DuplicateHandle (hp, dupsig, hMainProc, &sendsig, false, 0,
- DUPLICATE_SAME_ACCESS) || !sendsig)
+ if (!DuplicateHandle (hp, dupsig, GetCurrentProcess (), &sendsig, false,
+ 0, DUPLICATE_SAME_ACCESS) || !sendsig)
{
__seterrno ();
sigproc_printf ("DuplicateHandle failed, %E");
__seterrno ();
goto out;
}
- if (!DuplicateHandle (hMainProc, tome, hp, &tome, false, 0,
+ if (!DuplicateHandle (GetCurrentProcess (), tome, hp, &tome, false, 0,
DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE))
{
sigproc_printf ("DuplicateHandle for __SIGCOMMUNE failed, %E");
/* Create an inheritable handle to pass to the child process. This will
allow the child to duplicate handles from the parent to itself. */
parent = NULL;
- if (!DuplicateHandle (hMainProc, hMainProc, hMainProc, &parent, 0, TRUE,
+ if (!DuplicateHandle (GetCurrentProcess (), GetCurrentProcess (),
+ GetCurrentProcess (), &parent, 0, TRUE,
DUPLICATE_SAME_ACCESS))
system_printf ("couldn't create handle to myself for child, %E");
}
moreinfo->argv = newargv;
if (mode != _P_OVERLAY ||
- !DuplicateHandle (hMainProc, myself.shared_handle (), hMainProc,
- &moreinfo->myself_pinfo, 0, TRUE,
- DUPLICATE_SAME_ACCESS))
+ !DuplicateHandle (GetCurrentProcess (), myself.shared_handle (),
+ GetCurrentProcess (), &moreinfo->myself_pinfo,
+ 0, TRUE, DUPLICATE_SAME_ACCESS))
moreinfo->myself_pinfo = NULL;
else
VerifyHandle (moreinfo->myself_pinfo);
si.cb = sizeof (si);
- c_flags = GetPriorityClass (hMainProc);
+ c_flags = GetPriorityClass (GetCurrentProcess ());
sigproc_printf ("priority class %d", c_flags);
c_flags |= CREATE_SEPARATE_WOW_VDM | CREATE_UNICODE_ENVIRONMENT;
generating its own pids again? */
if (cygheap->pid_handle)
/* already done previously */;
- else if (DuplicateHandle (hMainProc, hMainProc, hMainProc,
- &cygheap->pid_handle, PROCESS_QUERY_INFORMATION,
- TRUE, 0))
+ else if (DuplicateHandle (GetCurrentProcess (), GetCurrentProcess (),
+ GetCurrentProcess (), &cygheap->pid_handle,
+ PROCESS_QUERY_INFORMATION, TRUE, 0))
ProtectHandleINH (cygheap->pid_handle);
else
system_printf ("duplicate to pid_handle failed, %E");
the fields filled out by child.remember do not disappear and so there
is not a brief period during which the pid is not available.
However, we should try to find another way to do this eventually. */
- DuplicateHandle (hMainProc, child.shared_handle (), pi.hProcess,
- NULL, 0, 0, DUPLICATE_SAME_ACCESS);
+ DuplicateHandle (GetCurrentProcess (), child.shared_handle (),
+ pi.hProcess, NULL, 0, 0, DUPLICATE_SAME_ACCESS);
child->start_time = time (NULL); /* Register child's starting time. */
child->nice = myself->nice;
if (!child.remember (mode == _P_DETACH))
debug_printf ("closing fd %d", i);
#endif
if (i == 2)
- DuplicateHandle (GetCurrentProcess (), fh->get_output_handle (), GetCurrentProcess (), &h, 0, false,
- DUPLICATE_SAME_ACCESS);
+ DuplicateHandle (GetCurrentProcess (), fh->get_output_handle (),
+ GetCurrentProcess (), &h,
+ 0, false, DUPLICATE_SAME_ACCESS);
fh->close ();
if (!norelease)
cygheap->fdtab.release (i);
who = myself->pid;
if ((pid_t) who == myself->pid)
{
- if (!SetPriorityClass (hMainProc, prio))
+ if (!SetPriorityClass (GetCurrentProcess (), prio))
{
set_errno (EACCES);
return -1;
set_tls_self_pointer (thread);
thread->thread_id = GetCurrentThreadId ();
- if (!DuplicateHandle (hMainProc, GetCurrentThread (), hMainProc,
- &thread->win32_obj_id, 0, FALSE, DUPLICATE_SAME_ACCESS))
+ if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
+ GetCurrentProcess (), &thread->win32_obj_id,
+ 0, FALSE, DUPLICATE_SAME_ACCESS))
api_fatal ("failed to create mainthread handle");
if (!thread->create_cancel_event ())
api_fatal ("couldn't create cancel event for main thread");
overflow. */
clock_t tc = (clock_t) (ticks * CLOCKS_PER_SEC / 1000);
- GetProcessTimes (hMainProc, &creation_time, &exit_time,
+ GetProcessTimes (GetCurrentProcess (), &creation_time, &exit_time,
&kernel_time, &user_time);
syscall_printf ("ticks %d, CLOCKS_PER_SEC %d", ticks, CLOCKS_PER_SEC);
if (!SetTokenInformation (hProcToken, TokenDefaultDacl, &dacl,
sizeof (dacl)))
system_printf ("SetTokenInformation (TokenDefaultDacl), %E");
- if ((status = NtSetSecurityObject (hMainProc, DACL_SECURITY_INFORMATION,
- psd)))
+ if ((status = NtSetSecurityObject (NtCurrentProcess (),
+ DACL_SECURITY_INFORMATION, psd)))
system_printf ("NtSetSecurityObject, %lx", status);
}
else
== VER_SUITE_TERMINAL)
((wincaps *)caps)->ts_has_dep_problem = true;
}
- if (NT_SUCCESS (NtQueryInformationProcess (GetCurrentProcess (),
+ if (NT_SUCCESS (NtQueryInformationProcess (NtCurrentProcess (),
ProcessWow64Information,
&wow64, sizeof wow64, NULL))
&& !wow64)
OSDN Git Service
