diff --git a/Makefile.in b/Makefile.in
new file mode 100644
index 0000000..b370cb0
--- /dev/null
+++ b/Makefile.in
@@ -0,0 +1,14 @@
+all:
+ ./lazy -x build
+
+install:
+ ./lazy -x build -e install
+
+clean:
+ rm -rf src
+ rm -rf lib
+ rm -f lazy
+ rm -f lazy.config.tag
+ rm -f lz_stack
+ rm -f *.objs
+ rm -rf *.lst
diff --git a/config.lzy b/config.lzy
new file mode 100644
index 0000000..1c83db3
--- /dev/null
+++ b/config.lzy
@@ -0,0 +1,28 @@
+# package
+lz_package=ntapi
+
+
+# toolchain
+lz_default_target=x86_64-nt64-midipix
+lz_default_arch=nt64
+lz_default_compiler=gcc
+
+
+# lazy
+export lz_cflags_cmdline=-Os
+export lz_cxxflags_cmdline=-Os
+lz_ldflags_cmdline=
+
+lz_cflags_debug=
+lz_cflags_release=
+
+lz_cflags_include_first=
+lz_cflags_include_last=
+lz_cflags_include_cmdline=
+lz_cxxflags_include_cmdline=
+
+lz_exec_prefix=
+lz_bindir=
+lz_libdir=
+lz_includedir=
+lz_syslibdir=
diff --git a/configure b/configure
new file mode 100755
index 0000000..8d175eb
--- /dev/null
+++ b/configure
@@ -0,0 +1,116 @@
+#!/bin/sh
+
+# a simple configure-make wrapper for use in conjunction with the 'lazy' build script.
+# 'lazy' is deviant, occasionally useful, and permissively licensed; get_lazy() below,
+# then look for configure.template in the root directory.
+
+init_vars()
+{
+ lz_config_dir=`readlink -f $(dirname $0)`
+ lz_pwd=`pwd`
+
+ if [ x"$lz_config" = x ]; then
+ . $lz_config_dir/config.lzy || exit 2
+ else
+ . "$lz_config" || exit 2
+ fi
+}
+
+
+error_msg()
+{
+ echo $@ >&2
+}
+
+
+require_out_of_tree()
+{
+ if [ x"$lz_config_dir" = x"$lz_pwd" ]; then
+ error_msg "$lz_package: out-of-tree builds are required."
+ error_msg "please invoke configure again from a clean build directory."
+ exit 2
+ fi
+
+ return 0
+}
+
+
+get_lazy()
+{
+ which lazy && lazy=`which lazy` && return 0
+
+ if ! [ -d slazy ]; then
+ git clone git://midipix.org/lazy slazy || exit 2
+ fi
+
+ lazy=$lz_pwd/slazy/lazy
+}
+
+
+lazy_approach()
+{
+ if [ x"$lz_prefix" = x ]; then
+ error_msg "prefix is required."
+ exit 2
+ fi
+
+ if [ x"$lz_arch" = x ]; then lz_arch=$lz_default_arch; fi
+ if [ x"$lz_subarch" = x ]; then lz_subarch=$lz_default_subarch; fi
+ if [ x"$lz_target" = x ]; then lz_target=$lz_default_target; fi
+ if [ x"$lz_compiler" = x ]; then lz_compiler=$lz_default_compiler; fi
+ if [ x"$lz_compiler" = x ]; then lz_compiler=gcc; fi
+
+ $lazy -x config $lz_debug \
+ -t $lz_target \
+ -a $lz_arch \
+ -c $lz_compiler \
+ -n $lz_package \
+ -p $lz_config_dir \
+ -f $lz_prefix \
+ || exit 2
+
+}
+
+
+lazy_copy()
+{
+ cp "$lz_config_dir/Makefile.in" "$lz_pwd/Makefile"
+}
+
+
+for arg ; do
+ case "$arg" in
+ --help) usage
+ ;;
+
+ --prefix=*)
+ lz_prefix=${arg#*=}
+ ;;
+ --host=*)
+ lz_target=${arg#*=}
+ ;;
+ --target=*)
+ lz_target=${arg#*=}
+ ;;
+ --compiler=*)
+ lz_compiler=${arg#*=}
+ ;;
+ --config=*)
+ lz_config=${arg#*=}
+ ;;
+ --debug)
+ lz_debug='-d'
+ ;;
+ *)
+ error_msg ${arg#}: "unsupported config argument."
+ exit 2
+ ;;
+ esac
+done
+
+
+init_vars
+require_out_of_tree
+get_lazy
+lazy_approach
+lazy_copy
diff --git a/include/ntapi/bits/i386/nt_atomic_i386_asm__gcc.h b/include/ntapi/bits/i386/nt_atomic_i386_asm__gcc.h
new file mode 100644
index 0000000..f6e11ca
--- /dev/null
+++ b/include/ntapi/bits/i386/nt_atomic_i386_asm__gcc.h
@@ -0,0 +1,533 @@
+#include <psxtypes/psxtypes.h>
+
+static __inline__ void at_locked_inc(
+ intptr_t volatile * ptr)
+{
+ __asm__(
+ "lock;"
+ "incl %0"
+ : "=m" (*ptr)
+ : "m" (*ptr)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_inc_32(
+ int32_t volatile * ptr)
+{
+ __asm__(
+ "lock;"
+ "incl %0"
+ : "=m" (*ptr)
+ : "m" (*ptr)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_inc_64(
+ int64_t volatile * ptr)
+{
+ __sync_fetch_and_add(ptr,1);
+}
+
+
+static __inline__ void at_locked_dec(
+ intptr_t volatile * ptr)
+{
+ __asm__(
+ "lock;"
+ "decl %0"
+ : "=m" (*ptr)
+ : "m" (*ptr)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_dec_32(
+ int32_t volatile * ptr)
+{
+ __asm__(
+ "lock;"
+ "decl %0"
+ : "=m" (*ptr)
+ : "m" (*ptr)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_dec_64(
+ int64_t volatile * ptr)
+{
+ __sync_fetch_and_sub(ptr,1);
+}
+
+
+static __inline__ void at_locked_add(
+ intptr_t volatile * ptr,
+ intptr_t val)
+{
+ __asm__(
+ "lock;"
+ "xaddl %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_add_32(
+ int32_t volatile * ptr,
+ int32_t val)
+{
+ __asm__(
+ "lock;"
+ "xaddl %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_add_64(
+ int64_t volatile * ptr,
+ int64_t val)
+{
+ __sync_fetch_and_add(ptr,val);
+}
+
+
+static __inline__ void at_locked_sub(
+ intptr_t volatile * ptr,
+ intptr_t val)
+{
+ val = -val;
+
+ __asm__(
+ "lock;"
+ "xaddl %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_sub_32(
+ int32_t volatile * ptr,
+ int32_t val)
+{
+ val = -val;
+
+ __asm__(
+ "lock;"
+ "xaddl %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_sub_64(
+ int64_t volatile * ptr,
+ int64_t val)
+{
+ __sync_fetch_and_sub(ptr,val);
+}
+
+
+static __inline__ intptr_t at_locked_xadd(
+ intptr_t volatile * ptr,
+ intptr_t val)
+{
+ __asm__(
+ "lock;"
+ "xaddl %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+ return val;
+}
+
+
+static __inline__ int32_t at_locked_xadd_32(
+ int32_t volatile * ptr,
+ int32_t val)
+{
+ __asm__(
+ "lock;"
+ "xaddl %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+ return val;
+}
+
+
+static __inline__ int64_t at_locked_xadd_64(
+ int64_t volatile * ptr,
+ int64_t val)
+{
+ return __sync_fetch_and_add(ptr,val);
+}
+
+
+static __inline__ intptr_t at_locked_xsub(
+ intptr_t volatile * ptr,
+ intptr_t val)
+{
+ val = -val;
+
+ __asm__(
+ "lock;"
+ "xaddl %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+ return val;
+}
+
+
+static __inline__ int32_t at_locked_xsub_32(
+ int32_t volatile * ptr,
+ int32_t val)
+{
+ val = -val;
+
+ __asm__(
+ "lock;"
+ "xaddl %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+ return val;
+}
+
+
+static __inline__ int64_t at_locked_xsub_64(
+ int64_t volatile * ptr,
+ int64_t val)
+{
+ return __sync_fetch_and_sub(ptr,val);
+}
+
+
+static __inline__ intptr_t at_locked_cas(
+ intptr_t volatile * dst,
+ intptr_t cmp,
+ intptr_t xchg)
+{
+ intptr_t ret;
+
+ __asm__(
+ "lock;"
+ "cmpxchg %3, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "a" (cmp), "r" (xchg)
+ : "memory");
+
+ return ret;
+}
+
+
+static __inline__ int32_t at_locked_cas_32(
+ int32_t volatile * dst,
+ int32_t cmp,
+ int32_t xchg)
+{
+ int32_t ret;
+
+ __asm__(
+ "lock;"
+ "cmpxchg %3, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "a" (cmp), "r" (xchg)
+ : "memory");
+
+ return ret;
+}
+
+
+static __inline__ int64_t at_locked_cas_64(
+ int64_t volatile * dst,
+ int64_t cmp,
+ int64_t xchg)
+{
+ __atomic_compare_exchange_n(
+ dst,
+ &cmp,
+ xchg,
+ 0,
+ __ATOMIC_SEQ_CST,
+ __ATOMIC_SEQ_CST);
+
+ return cmp;
+}
+
+
+static __inline__ intptr_t at_locked_and(
+ intptr_t volatile * dst,
+ intptr_t mask)
+{
+ intptr_t ret;
+
+ __asm__(
+ "lock;"
+ "andl %1, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "r" (mask)
+ : "memory");
+
+ return ret;
+}
+
+
+static __inline__ int32_t at_locked_and_32(
+ int32_t volatile * dst,
+ int32_t mask)
+{
+ int32_t ret;
+
+ __asm__(
+ "lock;"
+ "andl %1, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "r" (mask)
+ : "memory");
+
+ return ret;
+}
+
+
+static __inline__ int64_t at_locked_and_64(
+ int64_t volatile * dst,
+ int64_t mask)
+{
+ int64_t ret;
+ int64_t cmp;
+ int64_t xchg;
+
+ do {
+ cmp = *dst;
+ xchg = cmp & mask;
+ ret = at_locked_cas_64(dst,cmp,xchg);
+ } while (ret != cmp);
+
+ return ret;
+}
+
+
+static __inline__ intptr_t at_locked_or(
+ intptr_t volatile * dst,
+ intptr_t mask)
+{
+ intptr_t ret;
+
+ __asm__(
+ "lock;"
+ "orl %1, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "r" (mask)
+ : "memory");
+
+ return ret;
+}
+
+
+static __inline__ int32_t at_locked_or_32(
+ int32_t volatile * dst,
+ int32_t mask)
+{
+ int32_t ret;
+
+ __asm__(
+ "lock;"
+ "orl %1, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "r" (mask)
+ : "memory");
+
+ return ret;
+}
+
+
+static __inline__ int64_t at_locked_or_64(
+ int64_t volatile * dst,
+ int64_t mask)
+{
+ int64_t ret;
+ int64_t cmp;
+ int64_t xchg;
+
+ do {
+ cmp = *dst;
+ xchg = cmp | mask;
+ ret = at_locked_cas_64(dst,cmp,xchg);
+ } while (ret != cmp);
+
+ return ret;
+}
+
+
+static __inline__ intptr_t at_locked_xor(
+ intptr_t volatile * dst,
+ intptr_t mask)
+{
+ intptr_t ret;
+
+ __asm__(
+ "lock;"
+ "xorl %1, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "r" (mask)
+ : "memxory");
+
+ return ret;
+}
+
+
+static __inline__ int32_t at_locked_xor_32(
+ int32_t volatile * dst,
+ int32_t mask)
+{
+ int32_t ret;
+
+ __asm__(
+ "lock;"
+ "xorl %1, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "r" (mask)
+ : "memxory");
+
+ return ret;
+}
+
+
+static __inline__ int64_t at_locked_xor_64(
+ int64_t volatile * dst,
+ int64_t mask)
+{
+ int64_t ret;
+ int64_t cmp;
+ int64_t xchg;
+
+ do {
+ cmp = *dst;
+ xchg = cmp ^ mask;
+ ret = at_locked_cas_64(dst,cmp,xchg);
+ } while (ret != cmp);
+
+ return ret;
+}
+
+
+static __inline__ void at_store(
+ volatile intptr_t * dst,
+ intptr_t val)
+{
+ __asm__(
+ "mov %1, %0"
+ : "=m" (*dst)
+ : "r" (val)
+ : "memory");
+}
+
+
+static __inline__ void at_store_32(
+ volatile int32_t * dst,
+ int32_t val)
+{
+ __asm__(
+ "mov %1, %0"
+ : "=m" (*dst)
+ : "r" (val)
+ : "memory");
+}
+
+
+static __inline__ void at_store_64(
+ volatile int64_t * dst,
+ int64_t val)
+{
+ __asm__(
+ "mov %1, %0"
+ : "=m" (*dst)
+ : "r" (val)
+ : "memory");
+}
+
+
+static __inline__ int at_bsf(
+ unsigned int * index,
+ uintptr_t mask)
+{
+ if (mask) {
+ __asm__(
+ "bsf %1, %0"
+ : "=r" (mask)
+ : "r" (mask));
+
+ *index = (int)mask;
+ return 1;
+ } else
+ return 0;
+}
+
+
+static __inline__ int at_bsr(
+ unsigned int * index,
+ uintptr_t mask)
+{
+ if (mask) {
+ __asm__(
+ "bsr %1, %0"
+ : "=r" (mask)
+ : "r" (mask));
+
+ *index = (int)mask;
+ return 1;
+ } else
+ return 0;
+}
+
+
+static __inline__ size_t at_popcount(
+ uintptr_t mask)
+{
+ __asm__(
+ "popcnt %0, %0"
+ : "=r" (mask)
+ : "0" (mask)
+ : "memory");
+ return mask;
+}
+
+
+static __inline__ size_t at_popcount_16(
+ uint16_t mask)
+{
+ __asm__(
+ "popcnt %0, %0"
+ : "=r" (mask)
+ : "0" (mask)
+ : "memory");
+ return mask;
+}
+
+
+static __inline__ size_t at_popcount_32(
+ uint32_t mask)
+{
+ __asm__(
+ "popcnt %0, %0"
+ : "=r" (mask)
+ : "0" (mask)
+ : "memory");
+ return mask;
+}
+
+
+static __inline__ size_t at_popcount_64(
+ uint64_t mask)
+{
+ int ret = at_popcount_32(mask >> 32);
+ return ret + ((mask << 32) >> 32);
+}
diff --git a/include/ntapi/bits/i386/nt_atomic_i386_asm__msvc.h b/include/ntapi/bits/i386/nt_atomic_i386_asm__msvc.h
new file mode 100644
index 0000000..c0a0ba8
--- /dev/null
+++ b/include/ntapi/bits/i386/nt_atomic_i386_asm__msvc.h
@@ -0,0 +1,350 @@
+#include <psxtypes/psxtypes.h>
+
+long _InterlockedIncrement(long volatile * ptr);
+int64_t _InterlockedIncrement64(int64_t volatile * ptr);
+long _InterlockedDecrement(long volatile * ptr);
+int64_t _InterlockedDecrement64(int64_t volatile * ptr);
+long _InterlockedExchangeAdd(long volatile * ptr, long val);
+int64_t _InterlockedExchangeAdd64(int64_t volatile * ptr, int64_t val);
+long _InterlockedCompareExchange(long volatile * dst, long xchg, long cmp);
+int64_t _InterlockedCompareExchange64(int64_t volatile * dst, int64_t xchg, int64_t cmp);
+long _InterlockedAnd(long volatile * dst, long mask);
+int64_t _InterlockedAnd64(int64_t volatile * dst, int64_t mask);
+long _InterlockedOr(long volatile * dst, long mask);
+int64_t _InterlockedOr64(int64_t volatile * dst, int64_t mask);
+long _InterlockedXor(long volatile * dst, long mask);
+int64_t _InterlockedXor64(int64_t volatile * dst, int64_t mask);
+uint16_t __popcnt16(uint16_t mask);
+unsigned int __popcnt(uint32_t mask);
+uint64_t __popcnt64(uint64_t mask);
+void _ReadWriteBarrier(void);
+unsigned char _BitScanForward(unsigned int * index, uintptr_t mask);
+unsigned char _BitScanReverse(unsigned int * index, uintptr_t mask);
+
+static __inline__ void at_locked_inc(
+ intptr_t volatile * ptr)
+{
+ _InterlockedIncrement(ptr);
+ return;
+}
+
+
+static __inline__ void at_locked_inc_32(
+ int32_t volatile * ptr)
+{
+ _InterlockedIncrement((long *)ptr);
+ return;
+}
+
+
+static __inline__ void at_locked_inc_64(
+ int64_t volatile * ptr)
+{
+ _InterlockedIncrement64(ptr);
+ return;
+}
+
+
+static __inline__ void at_locked_dec(
+ intptr_t volatile * ptr)
+{
+ _InterlockedDecrement(ptr);
+ return;
+}
+
+
+static __inline__ void at_locked_dec_32(
+ int32_t volatile * ptr)
+{
+ _InterlockedDecrement((long *)ptr);
+ return;
+}
+
+
+static __inline__ void at_locked_dec_64(
+ int64_t volatile * ptr)
+{
+ _InterlockedDecrement64(ptr);
+ return;
+}
+
+
+static __inline__ void at_locked_add(
+ intptr_t volatile * ptr,
+ intptr_t val)
+{
+ _InterlockedExchangeAdd(ptr, val);
+ return;
+}
+
+
+static __inline__ void at_locked_add_32(
+ int32_t volatile * ptr,
+ int32_t val)
+{
+ _InterlockedExchangeAdd((long *)ptr, val);
+ return;
+}
+
+
+static __inline__ void at_locked_add_64(
+ int64_t volatile * ptr,
+ int64_t val)
+{
+ _InterlockedExchangeAdd64(ptr, val);
+ return;
+}
+
+
+static __inline__ void at_locked_sub(
+ intptr_t volatile * ptr,
+ intptr_t val)
+{
+ _InterlockedExchangeAdd(ptr, -val);
+ return;
+}
+
+
+static __inline__ void at_locked_sub_32(
+ int32_t volatile * ptr,
+ int32_t val)
+{
+ _InterlockedExchangeAdd((long *)ptr, -val);
+ return;
+}
+
+
+static __inline__ void at_locked_sub_64(
+ int64_t volatile * ptr,
+ int64_t val)
+{
+ _InterlockedExchangeAdd64(ptr, -val);
+ return;
+}
+
+
+static __inline__ intptr_t at_locked_xadd(
+ intptr_t volatile * ptr,
+ intptr_t val)
+{
+ return _InterlockedExchangeAdd(ptr, val);
+}
+
+
+static __inline__ int32_t at_locked_xadd_32(
+ int32_t volatile * ptr,
+ int32_t val)
+{
+ return _InterlockedExchangeAdd((long *)ptr, val);
+}
+
+
+static __inline__ int64_t at_locked_xadd_64(
+ int64_t volatile * ptr,
+ int64_t val)
+{
+ return _InterlockedExchangeAdd64(ptr, val);
+}
+
+
+static __inline__ intptr_t at_locked_xsub(
+ intptr_t volatile * ptr,
+ intptr_t val)
+{
+ return _InterlockedExchangeAdd(ptr, -val);
+}
+
+
+static __inline__ int32_t at_locked_xsub_32(
+ int32_t volatile * ptr,
+ int32_t val)
+{
+ return _InterlockedExchangeAdd((long *)ptr, -val);
+}
+
+
+static __inline__ int64_t at_locked_xsub_64(
+ int64_t volatile * ptr,
+ int64_t val)
+{
+ return _InterlockedExchangeAdd64(ptr, -val);
+}
+
+
+static __inline__ intptr_t at_locked_cas(
+ intptr_t volatile * dst,
+ intptr_t cmp,
+ intptr_t xchg)
+{
+ return _InterlockedCompareExchange(dst,xchg,cmp);
+}
+
+
+static __inline__ int32_t at_locked_cas_32(
+ int32_t volatile * dst,
+ int32_t cmp,
+ int32_t xchg)
+{
+ return _InterlockedCompareExchange((long *)dst,xchg,cmp);
+}
+
+
+static __inline__ int64_t at_locked_cas_64(
+ int64_t volatile * dst,
+ int64_t cmp,
+ int64_t xchg)
+{
+ return _InterlockedCompareExchange64(dst,xchg,cmp);
+}
+
+
+static __inline__ intptr_t at_locked_and(
+ intptr_t volatile * dst,
+ intptr_t mask)
+{
+ return _InterlockedAnd(dst,mask);
+}
+
+
+static __inline__ int32_t at_locked_and_32(
+ int32_t volatile * dst,
+ int32_t mask)
+{
+ return _InterlockedAnd((long *)dst,mask);
+}
+
+
+static __inline__ int64_t at_locked_and_64(
+ int64_t volatile * dst,
+ int64_t mask)
+{
+ return _InterlockedAnd64(dst,mask);
+}
+
+
+static __inline__ intptr_t at_locked_or(
+ intptr_t volatile * dst,
+ intptr_t mask)
+{
+ return _InterlockedOr(dst,mask);
+}
+
+
+static __inline__ int32_t at_locked_or_32(
+ int32_t volatile * dst,
+ int32_t mask)
+{
+ return _InterlockedOr((long *)dst,mask);
+}
+
+
+static __inline__ int64_t at_locked_or_64(
+ int64_t volatile * dst,
+ int64_t mask)
+{
+ return _InterlockedOr64(dst,mask);
+}
+
+
+static __inline__ intptr_t at_locked_xor(
+ intptr_t volatile * dst,
+ intptr_t mask)
+{
+ return _InterlockedXor(dst,mask);
+}
+
+
+static __inline__ int32_t at_locked_xor_32(
+ int32_t volatile * dst,
+ int32_t mask)
+{
+ return _InterlockedXor((long *)dst,mask);
+}
+
+
+static __inline__ int64_t at_locked_xor_64(
+ int64_t volatile * dst,
+ int64_t mask)
+{
+ return _InterlockedXor64(dst,mask);
+}
+
+
+static __inline__ void at_store(
+ volatile intptr_t * dst,
+ intptr_t val)
+{
+ _ReadWriteBarrier();
+ *dst = val;
+ _ReadWriteBarrier();
+
+ return;
+}
+
+
+static __inline__ void at_store_32(
+ volatile int32_t * dst,
+ int32_t val)
+{
+ _ReadWriteBarrier();
+ *dst = val;
+ _ReadWriteBarrier();
+
+ return;
+}
+
+
+static __inline__ void at_store_64(
+ volatile int64_t * dst,
+ int64_t val)
+{
+ _ReadWriteBarrier();
+ *dst = val;
+ _ReadWriteBarrier();
+
+ return;
+}
+
+
+static __inline__ int at_bsf(
+ unsigned int * index,
+ uintptr_t mask)
+{
+ return (int)_BitScanForward(index,mask);
+}
+
+
+static __inline__ int at_bsr(
+ unsigned int * index,
+ uintptr_t mask)
+{
+ return (int)_BitScanReverse(index,mask);
+}
+
+
+static __inline__ size_t at_popcount(
+ uintptr_t mask)
+{
+ return __popcnt(mask);
+}
+
+
+static __inline__ size_t at_popcount_16(
+ uint16_t mask)
+{
+ return __popcnt16(mask);
+}
+
+
+static __inline__ size_t at_popcount_32(
+ uint32_t mask)
+{
+ return __popcnt(mask);
+}
+
+
+static __inline__ size_t at_popcount_64(
+ uint64_t mask)
+{
+ return (size_t)__popcnt64(mask);
+}
diff --git a/include/ntapi/bits/i386/nt_thread_i386.h b/include/ntapi/bits/i386/nt_thread_i386.h
new file mode 100644
index 0000000..466d129
--- /dev/null
+++ b/include/ntapi/bits/i386/nt_thread_i386.h
@@ -0,0 +1,45 @@
+#include <psxtypes/psxtypes.h>
+
+typedef struct _nt_floating_save_area_i386 {
+ uint32_t uc_ctrl_word; /* 0x000 */
+ uint32_t uc_status_word; /* 0x004 */
+ uint32_t uc_tag_word; /* 0x008 */
+ uint32_t uc_error_offset; /* 0x00c */
+ uint32_t uc_error_selector; /* 0x010 */
+ uint32_t uc_data_offset; /* 0x014 */
+ uint32_t uc_data_selector; /* 0x018 */
+ unsigned char uc_reg_area[80]; /* 0x01c */
+ uint32_t uc_cr0_npx_state; /* 0x06c */
+} nt_floating_save_area_i386;
+
+
+typedef struct _nt_thread_context_i386 {
+ uint32_t uc_context_flags; /* 0x000 */
+ uint32_t uc_dr0; /* 0x004 */
+ uint32_t uc_dr1; /* 0x008 */
+ uint32_t uc_dr2; /* 0x00c */
+ uint32_t uc_dr3; /* 0x010 */
+ uint32_t uc_dr6; /* 0x014 */
+ uint32_t uc_dr7; /* 0x018 */
+
+ nt_floating_save_area_i386
+ uc_float_save; /* 0x01c */
+
+ uint32_t uc_seg_gs; /* 0x08c */
+ uint32_t uc_seg_fs; /* 0x090 */
+ uint32_t uc_seg_es; /* 0x094 */
+ uint32_t uc_seg_ds; /* 0x098 */
+ uint32_t uc_edi; /* 0x09c */
+ uint32_t uc_esi; /* 0x0a0 */
+ uint32_t uc_ebx; /* 0x0a4 */
+ uint32_t uc_edx; /* 0x0a8 */
+ uint32_t uc_ecx; /* 0x0ac */
+ uint32_t uc_eax; /* 0x0b0 */
+ uint32_t uc_ebp; /* 0x0b4 */
+ uint32_t uc_eip; /* 0x0b8 */
+ uint32_t uc_seg_cs; /* 0x0bc */
+ uint32_t uc_eflags; /* 0x0c0 */
+ uint32_t uc_esp; /* 0x0c4 */
+ uint32_t uc_seg_ss; /* 0x0c8 */
+ unsigned char uc_extended_regs[512]; /* 0x0cc */
+} nt_thread_context_i386;
diff --git a/include/ntapi/bits/nt_atomic_inline_asm.h b/include/ntapi/bits/nt_atomic_inline_asm.h
new file mode 100644
index 0000000..f749bdf
--- /dev/null
+++ b/include/ntapi/bits/nt_atomic_inline_asm.h
@@ -0,0 +1,15 @@
+#if defined(__X86_MODEL)
+#if (__COMPILER__ == __GCC__)
+#include "i386/nt_atomic_i386_asm__gcc.h"
+#elif (__COMPILER__ == __MSVC__)
+#include "i386/nt_atomic_i386_asm__msvc.h"
+#endif
+
+#elif defined(__X86_64_MODEL)
+#if (__COMPILER__ == __GCC__)
+#include "x86_64/nt_atomic_x86_64_asm__gcc.h"
+#elif (__COMPILER__ == __MSVC__)
+#include "x86_64/nt_atomic_x86_64_asm__msvc.h"
+#endif
+
+#endif
diff --git a/include/ntapi/bits/x86_64/nt_atomic_x86_64_asm__gcc.h b/include/ntapi/bits/x86_64/nt_atomic_x86_64_asm__gcc.h
new file mode 100644
index 0000000..b15bcdc
--- /dev/null
+++ b/include/ntapi/bits/x86_64/nt_atomic_x86_64_asm__gcc.h
@@ -0,0 +1,571 @@
+#include <psxtypes/psxtypes.h>
+
+static __inline__ void at_locked_inc(
+ intptr_t volatile * ptr)
+{
+ __asm__(
+ "lock;"
+ "incq %0"
+ : "=m" (*ptr)
+ : "m" (*ptr)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_inc_32(
+ int32_t volatile * ptr)
+{
+ __asm__(
+ "lock;"
+ "incl %0"
+ : "=m" (*ptr)
+ : "m" (*ptr)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_inc_64(
+ int64_t volatile * ptr)
+{
+ __asm__(
+ "lock;"
+ "incq %0"
+ : "=m" (*ptr)
+ : "m" (*ptr)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_dec(
+ intptr_t volatile * ptr)
+{
+ __asm__(
+ "lock;"
+ "decq %0"
+ : "=m" (*ptr)
+ : "m" (*ptr)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_dec_32(
+ int32_t volatile * ptr)
+{
+ __asm__(
+ "lock;"
+ "decl %0"
+ : "=m" (*ptr)
+ : "m" (*ptr)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_dec_64(
+ int64_t volatile * ptr)
+{
+ __asm__(
+ "lock;"
+ "decq %0"
+ : "=m" (*ptr)
+ : "m" (*ptr)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_add(
+ intptr_t volatile * ptr,
+ intptr_t val)
+{
+ __asm__(
+ "lock;"
+ "xaddq %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_add_32(
+ int32_t volatile * ptr,
+ int32_t val)
+{
+ __asm__(
+ "lock;"
+ "xaddl %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_add_64(
+ int64_t volatile * ptr,
+ int64_t val)
+{
+ __asm__(
+ "lock;"
+ "xaddq %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_sub(
+ intptr_t volatile * ptr,
+ intptr_t val)
+{
+ val = -val;
+
+ __asm__(
+ "lock;"
+ "xaddq %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_sub_32(
+ int32_t volatile * ptr,
+ int32_t val)
+{
+ val = -val;
+
+ __asm__(
+ "lock;"
+ "xaddl %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+}
+
+
+static __inline__ void at_locked_sub_64(
+ int64_t volatile * ptr,
+ int64_t val)
+{
+ val = -val;
+
+ __asm__(
+ "lock;"
+ "xaddq %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+}
+
+
+static __inline__ intptr_t at_locked_xadd(
+ intptr_t volatile * ptr,
+ intptr_t val)
+{
+ __asm__(
+ "lock;"
+ "xaddq %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+ return val;
+}
+
+
+static __inline__ int32_t at_locked_xadd_32(
+ int32_t volatile * ptr,
+ int32_t val)
+{
+ __asm__(
+ "lock;"
+ "xaddl %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+ return val;
+}
+
+
+static __inline__ int64_t at_locked_xadd_64(
+ int64_t volatile * ptr,
+ int64_t val)
+{
+ __asm__(
+ "lock;"
+ "xaddq %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+ return val;
+}
+
+
+static __inline__ intptr_t at_locked_xsub(
+ intptr_t volatile * ptr,
+ intptr_t val)
+{
+ val = -val;
+
+ __asm__(
+ "lock;"
+ "xaddq %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+ return val;
+}
+
+
+static __inline__ int32_t at_locked_xsub_32(
+ int32_t volatile * ptr,
+ int32_t val)
+{
+ val = -val;
+
+ __asm__(
+ "lock;"
+ "xaddl %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+ return val;
+}
+
+
+static __inline__ int64_t at_locked_xsub_64(
+ int64_t volatile * ptr,
+ int64_t val)
+{
+ val = -val;
+
+ __asm__(
+ "lock;"
+ "xaddq %1, %0"
+ : "=m" (*ptr), "=r" (val)
+ : "1" (val)
+ : "memory");
+ return val;
+}
+
+
+static __inline__ intptr_t at_locked_cas(
+ intptr_t volatile * dst,
+ intptr_t cmp,
+ intptr_t xchg)
+{
+ intptr_t ret;
+
+ __asm__(
+ "lock;"
+ "cmpxchgq %3, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "a" (cmp), "r" (xchg)
+ : "memory");
+
+ return ret;
+}
+
+
+static __inline__ int32_t at_locked_cas_32(
+ int32_t volatile * dst,
+ int32_t cmp,
+ int32_t xchg)
+{
+ int32_t ret;
+
+ __asm__(
+ "lock;"
+ "cmpxchg %3, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "a" (cmp), "r" (xchg)
+ : "memory");
+
+ return ret;
+}
+
+
+static __inline__ int64_t at_locked_cas_64(
+ int64_t volatile * dst,
+ int64_t cmp,
+ int64_t xchg)
+{
+ int64_t ret;
+
+ __asm__(
+ "lock;"
+ "cmpxchgq %3, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "a" (cmp), "r" (xchg)
+ : "memory");
+
+ return ret;
+}
+
+
+static __inline__ intptr_t at_locked_and(
+ intptr_t volatile * dst,
+ intptr_t mask)
+{
+ intptr_t ret;
+
+ __asm__(
+ "lock;"
+ "andq %1, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "r" (mask)
+ : "memory");
+
+ return ret;
+}
+
+
+static __inline__ int32_t at_locked_and_32(
+ int32_t volatile * dst,
+ int32_t mask)
+{
+ int32_t ret;
+
+ __asm__(
+ "lock;"
+ "andl %1, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "r" (mask)
+ : "memory");
+
+ return ret;
+}
+
+
+static __inline__ int64_t at_locked_and_64(
+ int64_t volatile * dst,
+ int64_t mask)
+{
+ int64_t ret;
+
+ __asm__(
+ "lock;"
+ "andq %1, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "r" (mask)
+ : "memory");
+
+ return ret;
+}
+
+
+static __inline__ intptr_t at_locked_or(
+ intptr_t volatile * dst,
+ intptr_t mask)
+{
+ intptr_t ret;
+
+ __asm__(
+ "lock;"
+ "orq %1, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "r" (mask)
+ : "memory");
+
+ return ret;
+}
+
+
+static __inline__ int32_t at_locked_or_32(
+ int32_t volatile * dst,
+ int32_t mask)
+{
+ int32_t ret;
+
+ __asm__(
+ "lock;"
+ "orl %1, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "r" (mask)
+ : "memory");
+
+ return ret;
+}
+
+
+static __inline__ int64_t at_locked_or_64(
+ int64_t volatile * dst,
+ int64_t mask)
+{
+ int64_t ret;
+
+ __asm__(
+ "lock;"
+ "orq %1, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "r" (mask)
+ : "memory");
+
+ return ret;
+}
+
+
+static __inline__ intptr_t at_locked_xor(
+ intptr_t volatile * dst,
+ intptr_t mask)
+{
+ intptr_t ret;
+
+ __asm__(
+ "lock;"
+ "xorq %1, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "r" (mask)
+ : "memxory");
+
+ return ret;
+}
+
+
+static __inline__ int32_t at_locked_xor_32(
+ int32_t volatile * dst,
+ int32_t mask)
+{
+ int32_t ret;
+
+ __asm__(
+ "lock;"
+ "xorl %1, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "r" (mask)
+ : "memxory");
+
+ return ret;
+}
+
+
+static __inline__ int64_t at_locked_xor_64(
+ int64_t volatile * dst,
+ int64_t mask)
+{
+ int64_t ret;
+
+ __asm__(
+ "lock;"
+ "xorq %1, %0"
+ : "=m" (*dst), "=a" (ret)
+ : "r" (mask)
+ : "memxory");
+
+ return ret;
+}
+
+
+static __inline__ void at_store(
+ volatile intptr_t * dst,
+ intptr_t val)
+{
+ __asm__(
+ "mov %1, %0"
+ : "=m" (*dst)
+ : "r" (val)
+ : "memory");
+}
+
+
+static __inline__ void at_store_32(
+ volatile int32_t * dst,
+ int32_t val)
+{
+ __asm__(
+ "mov %1, %0"
+ : "=m" (*dst)
+ : "r" (val)
+ : "memory");
+}
+
+
+static __inline__ void at_store_64(
+ volatile int64_t * dst,
+ int64_t val)
+{
+ __asm__(
+ "mov %1, %0"
+ : "=m" (*dst)
+ : "r" (val)
+ : "memory");
+}
+
+
+static __inline__ int at_bsf(
+ unsigned int * index,
+ uintptr_t mask)
+{
+ if (mask) {
+ __asm__(
+ "bsf %1, %0"
+ : "=r" (mask)
+ : "r" (mask));
+
+ *index = (int)mask;
+ return 1;
+ } else
+ return 0;
+}
+
+
+static __inline__ int at_bsr(
+ unsigned int * index,
+ uintptr_t mask)
+{
+ if (mask) {
+ __asm__(
+ "bsr %1, %0"
+ : "=r" (mask)
+ : "r" (mask));
+
+ *index = (int)mask;
+ return 1;
+ } else
+ return 0;
+}
+
+
+static __inline__ size_t at_popcount(
+ uintptr_t mask)
+{
+ __asm__(
+ "popcntq %0, %0"
+ : "=r" (mask)
+ : "0" (mask)
+ : "memory");
+ return mask;
+}
+
+
+static __inline__ size_t at_popcount_16(
+ uint16_t mask)
+{
+ __asm__(
+ "popcnt %0, %0"
+ : "=r" (mask)
+ : "0" (mask)
+ : "memory");
+ return mask;
+}
+
+
+static __inline__ size_t at_popcount_32(
+ uint32_t mask)
+{
+ __asm__(
+ "popcnt %0, %0"
+ : "=r" (mask)
+ : "0" (mask)
+ : "memory");
+ return mask;
+}
+
+
+static __inline__ size_t at_popcount_64(
+ uint64_t mask)
+{
+ __asm__(
+ "popcntq %0, %0"
+ : "=r" (mask)
+ : "0" (mask)
+ : "memory");
+ return mask;
+}
diff --git a/include/ntapi/bits/x86_64/nt_atomic_x86_64_asm__msvc.h b/include/ntapi/bits/x86_64/nt_atomic_x86_64_asm__msvc.h
new file mode 100644
index 0000000..a52bfd4
--- /dev/null
+++ b/include/ntapi/bits/x86_64/nt_atomic_x86_64_asm__msvc.h
@@ -0,0 +1,350 @@
+#include <psxtypes/psxtypes.h>
+
+long _InterlockedIncrement(int32_t volatile * ptr);
+int64_t _InterlockedIncrement64(int64_t volatile * ptr);
+long _InterlockedDecrement(int32_t volatile * ptr);
+int64_t _InterlockedDecrement64(int64_t volatile * ptr);
+long _InterlockedExchangeAdd(int32_t volatile * ptr, int32_t val);
+int64_t _InterlockedExchangeAdd64(int64_t volatile * ptr, int64_t val);
+long _InterlockedCompareExchange(int32_t volatile * dst, int32_t xchg, int32_t cmp);
+int64_t _InterlockedCompareExchange64(int64_t volatile * dst, int64_t xchg, int64_t cmp);
+long _InterlockedAnd(int32_t volatile * dst, int32_t mask);
+int64_t _InterlockedAnd64(int64_t volatile * dst, int64_t mask);
+long _InterlockedOr(int32_t volatile * dst, int32_t mask);
+int64_t _InterlockedOr64(int64_t volatile * dst, int64_t mask);
+long _InterlockedXor(int32_t volatile * dst, int32_t mask);
+int64_t _InterlockedXor64(int64_t volatile * dst, int64_t mask);
+uint16_t __popcnt16(uint16_t mask);
+uint32_t __popcnt(uint32_t mask);
+uint64_t __popcnt64(uint64_t mask);
+void _ReadWriteBarrier(void);
+unsigned char _BitScanForward64(unsigned int * index, uintptr_t mask);
+unsigned char _BitScanReverse64(unsigned int * index, uintptr_t mask);
+
+static __inline__ void at_locked_inc(
+ intptr_t volatile * ptr)
+{
+ _InterlockedIncrement64(ptr);
+ return;
+}
+
+
+static __inline__ void at_locked_inc_32(
+ int32_t volatile * ptr)
+{
+ _InterlockedIncrement(ptr);
+ return;
+}
+
+
+static __inline__ void at_locked_inc_64(
+ int64_t volatile * ptr)
+{
+ _InterlockedIncrement64(ptr);
+ return;
+}
+
+
+static __inline__ void at_locked_dec(
+ intptr_t volatile * ptr)
+{
+ _InterlockedDecrement64(ptr);
+ return;
+}
+
+
+static __inline__ void at_locked_dec_32(
+ int32_t volatile * ptr)
+{
+ _InterlockedDecrement(ptr);
+ return;
+}
+
+
+static __inline__ void at_locked_dec_64(
+ int64_t volatile * ptr)
+{
+ _InterlockedDecrement64(ptr);
+ return;
+}
+
+
+static __inline__ void at_locked_add(
+ intptr_t volatile * ptr,
+ intptr_t val)
+{
+ _InterlockedExchangeAdd64(ptr, val);
+ return;
+}
+
+
+static __inline__ void at_locked_add_32(
+ int32_t volatile * ptr,
+ int32_t val)
+{
+ _InterlockedExchangeAdd(ptr, val);
+ return;
+}
+
+
+static __inline__ void at_locked_add_64(
+ int64_t volatile * ptr,
+ int64_t val)
+{
+ _InterlockedExchangeAdd64(ptr, val);
+ return;
+}
+
+
+static __inline__ void at_locked_sub(
+ intptr_t volatile * ptr,
+ intptr_t val)
+{
+ _InterlockedExchangeAdd64(ptr, -val);
+ return;
+}
+
+
+static __inline__ void at_locked_sub_32(
+ int32_t volatile * ptr,
+ int32_t val)
+{
+ _InterlockedExchangeAdd(ptr, -val);
+ return;
+}
+
+
+static __inline__ void at_locked_sub_64(
+ int64_t volatile * ptr,
+ int64_t val)
+{
+ _InterlockedExchangeAdd64(ptr, -val);
+ return;
+}
+
+
+static __inline__ intptr_t at_locked_xadd(
+ intptr_t volatile * ptr,
+ intptr_t val)
+{
+ return _InterlockedExchangeAdd64(ptr, val);
+}
+
+
+static __inline__ int32_t at_locked_xadd_32(
+ int32_t volatile * ptr,
+ int32_t val)
+{
+ return _InterlockedExchangeAdd(ptr, val);
+}
+
+
+static __inline__ int64_t at_locked_xadd_64(
+ int64_t volatile * ptr,
+ int64_t val)
+{
+ return _InterlockedExchangeAdd64(ptr, val);
+}
+
+
+static __inline__ intptr_t at_locked_xsub(
+ intptr_t volatile * ptr,
+ intptr_t val)
+{
+ return _InterlockedExchangeAdd64(ptr, -val);
+}
+
+
+static __inline__ int32_t at_locked_xsub_32(
+ int32_t volatile * ptr,
+ int32_t val)
+{
+ return _InterlockedExchangeAdd(ptr, -val);
+}
+
+
+static __inline__ int64_t at_locked_xsub_64(
+ int64_t volatile * ptr,
+ int64_t val)
+{
+ return _InterlockedExchangeAdd64(ptr, -val);
+}
+
+
+static __inline__ intptr_t at_locked_cas(
+ intptr_t volatile * dst,
+ intptr_t cmp,
+ intptr_t xchg)
+{
+ return _InterlockedCompareExchange64(dst,xchg,cmp);
+}
+
+
+static __inline__ int32_t at_locked_cas_32(
+ int32_t volatile * dst,
+ int32_t cmp,
+ int32_t xchg)
+{
+ return _InterlockedCompareExchange(dst,xchg,cmp);
+}
+
+
+static __inline__ int64_t at_locked_cas_64(
+ int64_t volatile * dst,
+ int64_t cmp,
+ int64_t xchg)
+{
+ return _InterlockedCompareExchange64(dst,xchg,cmp);
+}
+
+
+static __inline__ intptr_t at_locked_and(
+ intptr_t volatile * dst,
+ intptr_t mask)
+{
+ return _InterlockedAnd64(dst,mask);
+}
+
+
+static __inline__ int32_t at_locked_and_32(
+ int32_t volatile * dst,
+ int32_t mask)
+{
+ return _InterlockedAnd(dst,mask);
+}
+
+
+static __inline__ int64_t at_locked_and_64(
+ int64_t volatile * dst,
+ int64_t mask)
+{
+ return _InterlockedAnd64(dst,mask);
+}
+
+
+static __inline__ intptr_t at_locked_or(
+ intptr_t volatile * dst,
+ intptr_t mask)
+{
+ return _InterlockedOr64(dst,mask);
+}
+
+
+static __inline__ int32_t at_locked_or_32(
+ int32_t volatile * dst,
+ int32_t mask)
+{
+ return _InterlockedOr(dst,mask);
+}
+
+
+static __inline__ int64_t at_locked_or_64(
+ int64_t volatile * dst,
+ int64_t mask)
+{
+ return _InterlockedOr64(dst,mask);
+}
+
+
+static __inline__ intptr_t at_locked_xor(
+ intptr_t volatile * dst,
+ intptr_t mask)
+{
+ return _InterlockedXor64(dst,mask);
+}
+
+
+static __inline__ int32_t at_locked_xor_32(
+ int32_t volatile * dst,
+ int32_t mask)
+{
+ return _InterlockedXor(dst,mask);
+}
+
+
+static __inline__ int64_t at_locked_xor_64(
+ int64_t volatile * dst,
+ int64_t mask)
+{
+ return _InterlockedXor64(dst,mask);
+}
+
+
+static __inline__ void at_store(
+ volatile intptr_t * dst,
+ intptr_t val)
+{
+ _ReadWriteBarrier();
+ *dst = val;
+ _ReadWriteBarrier();
+
+ return;
+}
+
+
+static __inline__ void at_store_32(
+ volatile int32_t * dst,
+ int32_t val)
+{
+ _ReadWriteBarrier();
+ *dst = val;
+ _ReadWriteBarrier();
+
+ return;
+}
+
+
+static __inline__ void at_store_64(
+ volatile int64_t * dst,
+ int64_t val)
+{
+ _ReadWriteBarrier();
+ *dst = val;
+ _ReadWriteBarrier();
+
+ return;
+}
+
+
+static __inline__ int at_bsf(
+ unsigned int * index,
+ uintptr_t mask)
+{
+ return (int)_BitScanForward64(index,mask);
+}
+
+
+static __inline__ int at_bsr(
+ unsigned int * index,
+ uintptr_t mask)
+{
+ return (int)_BitScanReverse64(index,mask);
+}
+
+
+static __inline__ size_t at_popcount(
+ uintptr_t mask)
+{
+ return __popcnt64(mask);
+}
+
+
+static __inline__ size_t at_popcount_16(
+ uint16_t mask)
+{
+ return __popcnt16(mask);
+}
+
+
+static __inline__ size_t at_popcount_32(
+ uint32_t mask)
+{
+ return __popcnt(mask);
+}
+
+
+static __inline__ size_t at_popcount_64(
+ uint64_t mask)
+{
+ return __popcnt64(mask);
+}
diff --git a/include/ntapi/bits/x86_64/nt_thread_x86_64.h b/include/ntapi/bits/x86_64/nt_thread_x86_64.h
new file mode 100644
index 0000000..efe5664
--- /dev/null
+++ b/include/ntapi/bits/x86_64/nt_thread_x86_64.h
@@ -0,0 +1,104 @@
+#ifndef _NT_THREAD_X86_64_H_
+#define _NT_THREAD_X86_64_H_
+
+#include <psxtypes/psxtypes.h>
+
+typedef struct {
+ uintptr_t uc_low;
+ intptr_t uc_high;
+} nt_m128a_t;
+
+typedef struct {
+ uint16_t uc_control_word; /* 0x000 */
+ uint16_t uc_status_word; /* 0x002 */
+ uint8_t uc_tag_word; /* 0x004 */
+ uint8_t uc_reserved1; /* 0x005 */
+ uint16_t uc_error_opcode; /* 0x006 */
+ uint32_t uc_error_offset; /* 0x008 */
+ uint16_t uc_error_selector; /* 0x00c */
+ uint16_t uc_reserved2; /* 0x00e */
+ uint32_t uc_data_offset; /* 0x010 */
+ uint16_t uc_data_selector; /* 0x014 */
+ uint16_t uc_reserved3; /* 0x016 */
+ uint32_t uc_mx_csr; /* 0x018 */
+ uint32_t uc_mx_csr_mask; /* 0x01c */
+ nt_m128a_t uc_float_registers[8]; /* 0x020 */
+ nt_m128a_t uc_xmm_registers[16]; /* 0x0a0 */
+ uint8_t uc_reserved4[96]; /* 0x1a0 */
+} nt_xsave_fmt_t;
+
+typedef struct {
+ uintptr_t uc_p1_home; /* 0x000 */
+ uintptr_t uc_p2_home; /* 0x008 */
+ uintptr_t uc_p3_home; /* 0x010 */
+ uintptr_t uc_p4_home; /* 0x018 */
+ uintptr_t uc_p5_home; /* 0x020 */
+ uintptr_t uc_p6_home; /* 0x028 */
+ uint32_t uc_context_flags; /* 0x030 */
+ uint32_t uc_mx_csr; /* 0x034 */
+ uint16_t uc_seg_cs; /* 0x038 */
+ uint16_t uc_seg_ds; /* 0x03a */
+ uint16_t uc_seg_es; /* 0x03c */
+ uint16_t uc_seg_fs; /* 0x03e */
+ uint16_t uc_seg_gs; /* 0x040 */
+ uint16_t uc_seg_ss; /* 0x042 */
+ uint32_t uc_eflags; /* 0x044 */
+ uintptr_t uc_dr0; /* 0x048 */
+ uintptr_t uc_dr1; /* 0x050 */
+ uintptr_t uc_dr2; /* 0x058 */
+ uintptr_t uc_dr3; /* 0x060 */
+ uintptr_t uc_dr6; /* 0x068 */
+ uintptr_t uc_dr7; /* 0x070 */
+ uintptr_t uc_rax; /* 0x078 */
+ uintptr_t uc_rcx; /* 0x080 */
+ uintptr_t uc_rdx; /* 0x088 */
+ uintptr_t uc_rbx; /* 0x090 */
+ uintptr_t uc_rsp; /* 0x098 */
+ uintptr_t uc_rbp; /* 0x0a0 */
+ uintptr_t uc_rsi; /* 0x0a8 */
+ uintptr_t uc_rdi; /* 0x0b0 */
+ uintptr_t uc_r8; /* 0x0b8 */
+ uintptr_t uc_r9; /* 0x0c0 */
+ uintptr_t uc_r10; /* 0x0c8 */
+ uintptr_t uc_r11; /* 0x0d0 */
+ uintptr_t uc_r12; /* 0x0d8 */
+ uintptr_t uc_r13; /* 0x0e0 */
+ uintptr_t uc_r14; /* 0x0e8 */
+ uintptr_t uc_r15; /* 0x0f0 */
+ uintptr_t uc_rip; /* 0x0f8 */
+
+ union {
+ nt_xsave_fmt_t uc_flt_save; /* 0x100 */
+
+ struct {
+ nt_m128a_t uc_header[2]; /* 0x100 */
+ nt_m128a_t uc_legacy[8]; /* 0x120 */
+ } uc_hdr;
+ } uc_flt;
+
+ nt_m128a_t uc_xmm0; /* 0x1a0 */
+ nt_m128a_t uc_xmm1; /* 0x1b0 */
+ nt_m128a_t uc_xmm2; /* 0x1c0 */
+ nt_m128a_t uc_xmm3; /* 0x1d0 */
+ nt_m128a_t uc_xmm4; /* 0x1e0 */
+ nt_m128a_t uc_xmm5; /* 0x1f0 */
+ nt_m128a_t uc_xmm6; /* 0x200 */
+ nt_m128a_t uc_xmm7; /* 0x210 */
+ nt_m128a_t uc_xmm8; /* 0x220 */
+ nt_m128a_t uc_xmm9; /* 0x230 */
+ nt_m128a_t uc_xmm10; /* 0x240 */
+ nt_m128a_t uc_xmm11; /* 0x250 */
+ nt_m128a_t uc_xmm12; /* 0x260 */
+ nt_m128a_t uc_xmm13; /* 0x270 */
+ nt_m128a_t uc_xmm14; /* 0x280 */
+ nt_m128a_t uc_xmm15; /* 0x290 */
+ nt_m128a_t uc_vector_register[26]; /* 0x300 */
+ uintptr_t uc_vector_control; /* 0x4a0 */
+ uintptr_t uc_debug_control; /* 0x4a8 */
+ uintptr_t uc_last_branch_to_rip; /* 0x4b0 */
+ uintptr_t uc_last_branch_from_rip; /* 0x4b8 */
+ uintptr_t uc_last_exception_to_rip; /* 0x4c0 */
+ uintptr_t uc_last_exception_from_rip; /* 0x4c8 */
+} nt_mcontext_x86_64_t;
+
+#endif
diff --git a/include/ntapi/nt_acl.h b/include/ntapi/nt_acl.h
new file mode 100644
index 0000000..8d82e0f
--- /dev/null
+++ b/include/ntapi/nt_acl.h
@@ -0,0 +1,109 @@
+#ifndef _NT_ACL_H_
+#define _NT_ACL_H_
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+
+typedef enum _nt_sid_name_use {
+ NT_SID_TYPE_USER = 1,
+ NT_SID_TYPE_GROUP,
+ NT_SID_TYPE_DOMAIN,
+ NT_SID_TYPE_ALIAS,
+ NT_SID_TYPE_WELL_KNOWN_GROUP,
+ NT_SID_TYPE_DELETED_ACCOUNT,
+ NT_SID_TYPE_INVALID,
+ NT_SID_TYPE_UNKNOWN,
+ NT_SID_TYPE_COMPUTER,
+ NT_SID_TYPE_LABEL
+} nt_sid_name_use;
+
+
+/* access control entry types */
+#define NT_ACE_TYPE_ACCESS_ALLOWED (0x00)
+#define NT_ACE_TYPE_ACCESS_DENIED (0x01)
+#define NT_ACE_TYPE_SYSTEM_AUDIT (0x02)
+#define NT_ACE_TYPE_SYSTEM_ALARM (0x03)
+#define NT_ACE_TYPE_ACCESS_ALLOWED_COMPOUND (0x04)
+#define NT_ACE_TYPE_ACCESS_ALLOWED_OBJECT (0x05)
+#define NT_ACE_TYPE_ACCESS_DENIED_OBJECT (0x06)
+#define NT_ACE_TYPE_SYSTEM_AUDIT_OBJECT (0x07)
+#define NT_ACE_TYPE_SYSTEM_ALARM_OBJECT (0x08)
+#define NT_ACE_TYPE_ACCESS_ALLOWED_CALLBACK (0x09)
+#define NT_ACE_TYPE_ACCESS_DENIED_CALLBACK (0x0A)
+#define NT_ACE_TYPE_ACCESS_ALLOWED_CALLBACK_OBJECT (0x0B)
+#define NT_ACE_TYPE_ACCESS_DENIED_CALLBACK_OBJECT (0x0C)
+#define NT_ACE_TYPE_SYSTEM_AUDIT_CALLBACK (0x0D)
+#define NT_ACE_TYPE_SYSTEM_ALARM_CALLBACK (0x0E)
+#define NT_ACE_TYPE_SYSTEM_AUDIT_CALLBACK_OBJECT (0x0F)
+#define NT_ACE_TYPE_SYSTEM_ALARM_CALLBACK_OBJECT (0x10)
+#define NT_ACE_TYPE_SYSTEM_MANDATORY_LABEL (0x11)
+#define NT_ACE_TYPE_SYSTEM_RESOURCE_ATTRIBUTE (0x12)
+#define NT_ACE_TYPE_SYSTEM_SCOPED_POLICY_ID (0x13)
+
+
+/* acceess control entry flags */
+#define NT_ACE_OBJECT_INHERIT (0x01)
+#define NT_ACE_CONTAINER_INHERIT (0x02)
+#define NT_ACE_NO_PROPAGATE_INHERIT (0x04)
+#define NT_ACE_INHERIT_ONLY (0x08)
+#define NT_ACE_INHERITED (0x10)
+#define NT_ACE_VALID_INHERIT_FLAGS (0x1F)
+#define NT_ACE_SUCCESSFUL_ACCESS_ACE_FLAG (0x40)
+#define NT_ACE_FAILED_ACCESS_ACE_FLAG (0x80)
+
+typedef struct _nt_ace_header {
+ unsigned char ace_type;
+ unsigned char ace_flags;
+ uint16_t ace_size;
+} nt_ace_header;
+
+
+typedef struct _nt_access_allowed_ace {
+ nt_ace_header header;
+ uint32_t mask;
+ uint32_t sid_start;
+} nt_access_allowed_ace;
+
+
+typedef struct _nt_access_denied_ace {
+ nt_ace_header header;
+ uint32_t mask;
+ uint32_t sid_start;
+} nt_access_denied_ace;
+
+
+typedef struct _nt_system_audit_ace {
+ nt_ace_header header;
+ uint32_t mask;
+ uint32_t sid_start;
+} nt_system_audit_ace;
+
+
+typedef struct _nt_system_alarm_ace {
+ nt_ace_header header;
+ uint32_t mask;
+ uint32_t sid_start;
+} nt_system_alarm_ace;
+
+
+typedef struct _nt_system_resource_attribute_ace {
+ nt_ace_header header;
+ uint32_t mask;
+ uint32_t sid_start;
+} nt_system_resource_attribute_ace;
+
+
+typedef struct _nt_system_scoped_policy_id_ace {
+ nt_ace_header header;
+ uint32_t mask;
+ uint32_t sid_start;
+} nt_system_scoped_policy_id_ace;
+
+
+typedef struct _nt_system_mandatory_label_ace {
+ nt_ace_header header;
+ uint32_t mask;
+ uint32_t sid_start;
+} nt_system_mandatory_label_ace;
+
+#endif
diff --git a/include/ntapi/nt_argv.h b/include/ntapi/nt_argv.h
new file mode 100644
index 0000000..eae5996
--- /dev/null
+++ b/include/ntapi/nt_argv.h
@@ -0,0 +1,204 @@
+#ifndef _NT_ARGV_H_
+#define _NT_ARGV_H_
+
+/******************************************************
+ * *
+ * this header is REALLY NOT what you are looking *
+ * for, however if you are into writing your apps *
+ * using the Native API only, then you might find *
+ * the below interfaces somehow useful. *
+ * *
+ *****************************************************/
+
+#include <psxtypes/psxtypes.h>
+
+/* ntapi_tt_get_argv_envp_utf16 flag bits */
+#define NT_GET_ARGV_ENVP_USE_INTERNAL_BUFFER (0x0000)
+#define NT_GET_ARGV_ENVP_USE_CALLER_BUFFER (0x0001)
+#define NT_GET_ARGV_ENVP_COPY_ENVIRONMENT (0x0002)
+#define NT_GET_ARGV_ENVP_VALIDATE_UTF16 (0x0004)
+
+/* ntapi_tt_program_option flag bits */
+#define NT_OPTION_SHORT (0x0001)
+#define NT_OPTION_LONG (0x0002)
+#define NT_OPTION_ALLOWED_ONCE (0x0100)
+#define NT_OPTION_ALLOWED_MANY (0x0200)
+#define NT_OPTION_REQUIRED (0x0400)
+#define NT_OPTION_VALUE_REQUIRED (0x1000)
+
+typedef struct _nt_program_option {
+ int option_count;
+ wchar16_t short_name_code;
+ wchar16_t * long_name;
+ uint32_t long_name_hash;
+ wchar16_t * value;
+ uint32_t value_hash;
+ uint32_t flags;
+} nt_program_option;
+
+
+typedef struct _nt_program_options_meta {
+ int idx_next_argument;
+ int idx_invalid_short_name;
+ int idx_invalid_long_name;
+ int idx_invalid_argument;
+ int idx_missing_option_value;
+} nt_program_options_meta;
+
+
+typedef struct _nt_env_var_meta_utf16 {
+ wchar16_t * name;
+ uint32_t name_hash;
+ wchar16_t * value;
+ uint32_t value_hash;
+ int envp_index;
+ uint32_t flags;
+} nt_env_var_meta_utf16;
+
+
+typedef struct _nt_cmd_option_meta_utf16 {
+ wchar16_t * short_name;
+ uint32_t short_name_code;
+ wchar16_t * long_name;
+ uint32_t long_name_hash;
+ wchar16_t * value;
+ uint32_t value_hash;
+ int argv_index;
+ uint32_t flags;
+} nt_cmd_option_meta_utf16;
+
+
+typedef struct _nt_argv_envp_block_info {
+ wchar16_t * cmd_line;
+ wchar16_t ** wargv_buffer;
+ size_t wargv_buffer_len;
+ wchar16_t * wargs_buffer;
+ size_t wargs_buffer_len;
+ size_t wargs_bytes_written;
+ wchar16_t ** wenvp_buffer;
+ size_t wenvp_buffer_len;
+ wchar16_t * wenvs_buffer;
+ size_t wenvs_buffer_len;
+ size_t wenvs_bytes_used;
+ char * args_buffer;
+ size_t args_buffer_len;
+ size_t args_bytes_written;
+ char * envs_buffer;
+ size_t envs_buffer_len;
+ size_t envs_bytes_used;
+ uint32_t arg_flags;
+ uint32_t env_flags;
+ uint32_t psx_flags;
+ uint32_t psx_padding;
+ uint32_t argv_envp_ptr_total;
+ int envc;
+
+ int argc;
+ char ** argv;
+ char ** envp;
+} nt_argv_envp_block_info;
+
+
+typedef struct _nt_get_argv_envp_ext_params {
+ nt_argv_envp_block_info argv_envp_block_info;
+} nt_get_argv_envp_ext_params;
+
+
+typedef wchar16_t * __stdcall ntapi_tt_get_cmd_line_utf16(void);
+
+
+typedef wchar16_t * __stdcall ntapi_tt_get_peb_env_block_utf16(void);
+
+
+typedef int32_t __stdcall ntapi_tt_parse_cmd_line_args_utf16(
+ __in wchar16_t * cmd_line,
+ __out int * arg_count,
+ __in wchar16_t * args_buffer,
+ __in size_t args_buffer_len,
+ __out size_t * args_bytes_written __optional,
+ __in wchar16_t ** argv_buffer,
+ __in size_t argv_buffer_len,
+ __in uint32_t arg_flags);
+
+
+typedef int32_t __stdcall ntapi_tt_get_argv_envp_utf8(
+ __out int * argc,
+ __out char *** argv,
+ __out char *** envp,
+ __in uint32_t flags,
+ __in void * ext_params __optional,
+ __out void * reserved __optional);
+
+
+typedef int32_t __stdcall ntapi_tt_get_argv_envp_utf16(
+ __out int * argc,
+ __out wchar16_t *** wargv,
+ __out wchar16_t *** wenvp,
+ __in uint32_t flags,
+ __in void * ext_params __optional,
+ __out void * reserved __optional);
+
+
+typedef int32_t __stdcall ntapi_tt_get_env_var_meta_utf16(
+ __in const uint32_t * crc32_table,
+ __in wchar16_t * env_var_name,
+ __in uint32_t env_var_name_hash __optional,
+ __in wchar16_t ** envp,
+ __out nt_env_var_meta_utf16 * env_var_meta);
+
+
+typedef int32_t __stdcall ntapi_tt_get_short_option_meta_utf16(
+ __in const uint32_t * crc32_table,
+ __in wchar16_t option_name,
+ __in wchar16_t * argv[],
+ __out nt_cmd_option_meta_utf16 * cmd_opt_meta);
+
+
+typedef int32_t __stdcall ntapi_tt_get_long_option_meta_utf16(
+ __in const uint32_t * crc32_table,
+ __in wchar16_t * option_name,
+ __in uint32_t option_name_hash __optional,
+ __in wchar16_t * argv[],
+ __out nt_cmd_option_meta_utf16 * cmd_opt_meta);
+
+typedef int32_t __stdcall ntapi_tt_array_copy_utf8(
+ __out int * argc,
+ __in const char ** argv,
+ __in const char ** wenvp,
+ __in const char * image_name __optional,
+ __in const char * interpreter __optional,
+ __in const char * optarg __optional,
+ __in void * base,
+ __out void * buffer,
+ __in size_t buflen,
+ __out size_t * blklen);
+
+typedef int32_t __stdcall ntapi_tt_array_copy_utf16(
+ __out int * argc,
+ __in const wchar16_t ** wargv,
+ __in const wchar16_t ** wenvp,
+ __in const wchar16_t * image_name __optional,
+ __in const wchar16_t * interpreter __optional,
+ __in const wchar16_t * optarg __optional,
+ __in void * base,
+ __out void * buffer,
+ __in size_t buflen,
+ __out size_t * blklen);
+
+typedef int32_t __stdcall ntapi_tt_array_convert_utf8_to_utf16(
+ __in char ** arrv,
+ __in wchar16_t ** arra,
+ __in void * base,
+ __in wchar16_t * buffer,
+ __in size_t buffer_len,
+ __out size_t * bytes_written);
+
+typedef int32_t __stdcall ntapi_tt_array_convert_utf16_to_utf8(
+ __in wchar16_t ** warrv,
+ __in char ** arra,
+ __in void * base,
+ __in char * buffer,
+ __in size_t buffer_len,
+ __out size_t * bytes_written);
+
+#endif
diff --git a/include/ntapi/nt_atom.h b/include/ntapi/nt_atom.h
new file mode 100644
index 0000000..36d660d
--- /dev/null
+++ b/include/ntapi/nt_atom.h
@@ -0,0 +1,52 @@
+#ifndef _NT_ATOM_H_
+#define _NT_ATOM_H_
+
+#include <psxtypes/psxtypes.h>
+
+typedef enum _nt_atom_info_class {
+ NT_ATOM_BASIC_INFORMATION,
+ NT_ATOM_LIST_INFORMATION
+} nt_atom_info_class;
+
+
+typedef uint16_t nt_atom;
+
+
+typedef struct _nt_atom_basic_information {
+ uint16_t reference_count;
+ uint16_t pinned;
+ uint16_t name_length;
+ wchar16_t name[];
+} nt_atom_basic_information;
+
+
+typedef struct _nt_atom_list_information {
+ uint32_t number_of_atoms;
+ nt_atom atoms[2];
+} nt_atom_list_information;
+
+
+typedef int32_t __stdcall ntapi_zw_add_atom(
+ __in wchar16_t str,
+ __in uint16_t str_length,
+ __out uint16_t * atom);
+
+
+typedef int32_t __stdcall ntapi_zw_find_atom(
+ __in wchar16_t str,
+ __in uint16_t str_length,
+ __out uint16_t * atom);
+
+
+typedef int32_t __stdcall ntapi_zw_delete_atom(
+ __in uint16_t * atom);
+
+
+typedef int32_t __stdcall ntapi_zw_query_information_atom(
+ __in uint16_t * atom,
+ __in nt_atom_info_class atom_info_class,
+ __out void * atom_info,
+ __in uint32_t atom_info_length,
+ __out uint32_t * returned_length __optional);
+
+#endif
diff --git a/include/ntapi/nt_atomic.h b/include/ntapi/nt_atomic.h
new file mode 100644
index 0000000..068b4e2
--- /dev/null
+++ b/include/ntapi/nt_atomic.h
@@ -0,0 +1,157 @@
+#ifndef _NT_ATOMIC_H_
+#define _NT_ATOMIC_H_
+
+#include <psxtypes/psxtypes.h>
+
+static __inline__ void at_locked_inc(
+ intptr_t volatile * ptr);
+
+static __inline__ void at_locked_inc_32(
+ int32_t volatile * ptr);
+
+static __inline__ void at_locked_inc_64(
+ int64_t volatile * ptr);
+
+static __inline__ void at_locked_dec(
+ intptr_t volatile * ptr);
+
+static __inline__ void at_locked_dec_32(
+ int32_t volatile * ptr);
+
+static __inline__ void at_locked_dec_64(
+ int64_t volatile * ptr);
+
+static __inline__ void at_locked_add(
+ intptr_t volatile * ptr,
+ intptr_t val);
+
+static __inline__ void at_locked_add_32(
+ int32_t volatile * ptr,
+ int32_t val);
+
+static __inline__ void at_locked_add_64(
+ int64_t volatile * ptr,
+ int64_t val);
+
+static __inline__ void at_locked_sub(
+ intptr_t volatile * ptr,
+ intptr_t val);
+
+static __inline__ void at_locked_sub_32(
+ int32_t volatile * ptr,
+ int32_t val);
+
+static __inline__ void at_locked_sub_64(
+ int64_t volatile * ptr,
+ int64_t val);
+
+static __inline__ intptr_t at_locked_xadd(
+ intptr_t volatile * ptr,
+ intptr_t val);
+
+static __inline__ int32_t at_locked_xadd_32(
+ int32_t volatile * ptr,
+ int32_t val);
+
+static __inline__ int64_t at_locked_xadd_64(
+ int64_t volatile * ptr,
+ int64_t val);
+
+static __inline__ intptr_t at_locked_xsub(
+ intptr_t volatile * ptr,
+ intptr_t val);
+
+static __inline__ int32_t at_locked_xsub_32(
+ int32_t volatile * ptr,
+ int32_t val);
+
+static __inline__ int64_t at_locked_xsub_64(
+ int64_t volatile * ptr,
+ int64_t val);
+
+static __inline__ intptr_t at_locked_cas(
+ intptr_t volatile * dst,
+ intptr_t cmp,
+ intptr_t xchg);
+
+static __inline__ int32_t at_locked_cas_32(
+ int32_t volatile * dst,
+ int32_t cmp,
+ int32_t xchg);
+
+static __inline__ int64_t at_locked_cas_64(
+ int64_t volatile * dst,
+ int64_t cmp,
+ int64_t xchg);
+
+static __inline__ intptr_t at_locked_and(
+ intptr_t volatile * dst,
+ intptr_t mask);
+
+
+static __inline__ int32_t at_locked_and_32(
+ int32_t volatile * dst,
+ int32_t mask);
+
+
+static __inline__ int64_t at_locked_and_64(
+ int64_t volatile * dst,
+ int64_t mask);
+
+
+static __inline__ intptr_t at_locked_or(
+ intptr_t volatile * dst,
+ intptr_t mask);
+
+
+static __inline__ int32_t at_locked_or_32(
+ int32_t volatile * dst,
+ int32_t mask);
+
+
+static __inline__ int64_t at_locked_or_64(
+ int64_t volatile * dst,
+ int64_t mask);
+
+
+static __inline__ intptr_t at_locked_xor(
+ intptr_t volatile * dst,
+ intptr_t mask);
+
+
+static __inline__ int32_t at_locked_xor_32(
+ int32_t volatile * dst,
+ int32_t mask);
+
+
+static __inline__ int64_t at_locked_xor_64(
+ int64_t volatile * dst,
+ int64_t mask);
+
+static __inline__ void at_store(
+ volatile intptr_t * dst,
+ intptr_t val);
+
+static __inline__ int at_bsf(
+ unsigned int * index,
+ uintptr_t mask);
+
+static __inline__ int at_bsr(
+ unsigned int * index,
+ uintptr_t mask);
+
+static __inline__ size_t at_popcount(
+ uintptr_t mask);
+
+static __inline__ size_t at_popcount_16(
+ uint16_t mask);
+
+static __inline__ size_t at_popcount_32(
+ uint32_t mask);
+
+static __inline__ size_t at_popcount_64(
+ uint64_t mask);
+
+#include "bits/nt_atomic_inline_asm.h"
+
+#endif
diff --git a/include/ntapi/nt_auxv.h b/include/ntapi/nt_auxv.h
new file mode 100644
index 0000000..d460c82
--- /dev/null
+++ b/include/ntapi/nt_auxv.h
@@ -0,0 +1,50 @@
+#ifndef _NT_AUXV_H_
+#define _NT_AUXV_H_
+
+#include <psxtypes/psxtypes.h>
+
+#define NT_AT_NULL 0
+#define NT_AT_IGNORE 1
+#define NT_AT_EXECFD 2
+#define NT_AT_PHDR 3
+#define NT_AT_PHENT 4
+#define NT_AT_PHNUM 5
+#define NT_AT_PAGESZ 6
+#define NT_AT_BASE 7
+#define NT_AT_FLAGS 8
+#define NT_AT_ENTRY 9
+#define NT_AT_NOTELF 10
+#define NT_AT_UID 11
+#define NT_AT_EUID 12
+#define NT_AT_GID 13
+#define NT_AT_EGID 14
+#define NT_AT_CLKTCK 17
+#define NT_AT_PLATFORM 15
+#define NT_AT_HWCAP 16
+#define NT_AT_FPUCW 18
+#define NT_AT_DCACHEBSIZE 19
+#define NT_AT_ICACHEBSIZE 20
+#define NT_AT_UCACHEBSIZE 21
+#define NT_AT_IGNOREPPC 22
+#define AT_SECURE 23
+#define NT_AT_BASE_PLATFORM 24
+#define NT_AT_RANDOM 25
+#define NT_AT_HWCAP2 26
+#define NT_AT_EXECFN 31
+#define NT_AT_SYSINFO 32
+#define NT_AT_SYSINFO_EHDR 33
+#define NT_AT_L1I_CACHESHAPE 34
+#define NT_AT_L1D_CACHESHAPE 35
+#define NT_AT_L2_CACHESHAPE 36
+#define NT_AT_L3_CACHESHAPE 37
+#define NT_AT_ARRAY_CAP 38
+
+typedef struct _nt_auxv_t {
+ uintptr_t a_type;
+
+ union {
+ uintptr_t a_val;
+ } a_un;
+} nt_auxv_t;
+
+#endif
diff --git a/include/ntapi/nt_blitter.h b/include/ntapi/nt_blitter.h
new file mode 100644
index 0000000..529a843
--- /dev/null
+++ b/include/ntapi/nt_blitter.h
@@ -0,0 +1,129 @@
+#ifndef _NT_BLITTER_H_
+#define _NT_BLITTER_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+
+/* blt_alloc flag bits */
+#define NT_BLITTER_ENABLE_BLOCK_ARRAY 0x01
+#define NT_BLITTER_ENABLE_BLOCK_SECTIONS 0x02
+#define NT_BLITTER_ENABLE_CACHE 0x04
+#define NT_BLITTER_PRESERVE_BITS 0x08
+
+/* blitter query type bits */
+#define NT_BLITTER_QUERY_INFO 0x01
+#define NT_BLITTER_QUERY_PARAMS 0x02
+
+/* blitter context (opaque) */
+typedef struct nt_blitter_context nt_blitter;
+
+typedef struct _nt_blitter_params {
+ size_t params_size;
+ size_t block_size;
+ intptr_t block_count;
+ intptr_t cache_blocks_min; __optional
+ intptr_t cache_blocks_max; __optional
+ size_t zero_bits; __optional
+ uint32_t srvtid; __optional
+ uint32_t flags; __optional
+ int32_t lock_tries; __optional
+ int32_t round_trips; __optional
+ void * hsignal_blt; __optional
+ void * hsignal_app; __optional
+ void * bitmap; __optional
+ void * region; __optional
+} nt_blitter_params;
+
+
+typedef struct _nt_blitter_info {
+ size_t info_size;
+ void * region_addr;
+ size_t region_size;
+ size_t block_size;
+ intptr_t block_count;
+ intptr_t blocks_used;
+ intptr_t blocks_avail;
+ intptr_t blocks_cached;
+ intptr_t lock_tries;
+ intptr_t busy;
+} nt_blitter_info;
+
+
+typedef struct _nt_blitter_query {
+ size_t size;
+ int32_t type;
+ uint32_t flags;
+ nt_blitter_params * params;
+ nt_blitter_info * info;
+} nt_blitter_query;
+
+
+typedef struct _nt_blitter_config {
+ size_t size;
+ int32_t type;
+ uint32_t flags;
+ nt_blitter_params * params;
+} nt_blitter_config;
+
+
+/* blitter functions */
+typedef int32_t __fastcall ntapi_blt_alloc(
+ __out nt_blitter ** blitter,
+ __in nt_blitter_params * params);
+
+
+typedef int32_t __fastcall ntapi_blt_free(
+ __in nt_blitter * blitter);
+
+
+typedef int32_t __fastcall ntapi_blt_query(
+ __in nt_blitter * blitter,
+ __in nt_blitter_query * blt_query);
+
+
+typedef int32_t __fastcall ntapi_blt_config(
+ __in nt_blitter * blitter,
+ __in nt_blitter_config * blt_config);
+
+
+typedef int32_t __fastcall ntapi_blt_acquire(
+ __in nt_blitter * blitter,
+ __out intptr_t * block_id);
+
+
+typedef int32_t __fastcall ntapi_blt_obtain(
+ __in nt_blitter * blitter,
+ __out intptr_t * block_id);
+
+
+typedef int32_t __fastcall ntapi_blt_possess(
+ __in nt_blitter * blitter,
+ __out intptr_t * block_id);
+
+
+typedef int32_t __fastcall ntapi_blt_release(
+ __in nt_blitter * blitter,
+ __in intptr_t block_id);
+
+
+typedef void * __fastcall ntapi_blt_region(
+ __in const nt_blitter * blitter);
+
+
+/**
+ * blt_get,blt_set:
+ * clients might prefr to write inlined
+ * alternatives that use a cached blt_region.
+**/
+typedef void * __fastcall ntapi_blt_get(
+ __in const nt_blitter * blitter,
+ __in intptr_t block_id);
+
+
+typedef void __fastcall ntapi_blt_set(
+ __in const nt_blitter * blitter,
+ __in intptr_t block_id,
+ __in void * val);
+
+
+#endif
diff --git a/include/ntapi/nt_crc32.h b/include/ntapi/nt_crc32.h
new file mode 100644
index 0000000..9f08e12
--- /dev/null
+++ b/include/ntapi/nt_crc32.h
@@ -0,0 +1,95 @@
+#ifndef _NT_CRC32_H_
+#define _NT_CRC32_H_
+
+#include <psxtypes/psxtypes.h>
+
+#define NTAPI_CRC32_POLY 0xd35a6b40
+
+#define NTAPI_CRC32_TABLE { \
+ 0x00000000, 0xd2fcdf96, 0x034d69ad, 0xd1b1b63b, \
+ 0x069ad35a, 0xd4660ccc, 0x05d7baf7, 0xd72b6561, \
+ 0x0d35a6b4, 0xdfc97922, 0x0e78cf19, 0xdc84108f, \
+ 0x0baf75ee, 0xd953aa78, 0x08e21c43, 0xda1ec3d5, \
+ 0x1a6b4d68, 0xc89792fe, 0x192624c5, 0xcbdafb53, \
+ 0x1cf19e32, 0xce0d41a4, 0x1fbcf79f, 0xcd402809, \
+ 0x175eebdc, 0xc5a2344a, 0x14138271, 0xc6ef5de7, \
+ 0x11c43886, 0xc338e710, 0x1289512b, 0xc0758ebd, \
+ 0x34d69ad0, 0xe62a4546, 0x379bf37d, 0xe5672ceb, \
+ 0x324c498a, 0xe0b0961c, 0x31012027, 0xe3fdffb1, \
+ 0x39e33c64, 0xeb1fe3f2, 0x3aae55c9, 0xe8528a5f, \
+ 0x3f79ef3e, 0xed8530a8, 0x3c348693, 0xeec85905, \
+ 0x2ebdd7b8, 0xfc41082e, 0x2df0be15, 0xff0c6183, \
+ 0x282704e2, 0xfadbdb74, 0x2b6a6d4f, 0xf996b2d9, \
+ 0x2388710c, 0xf174ae9a, 0x20c518a1, 0xf239c737, \
+ 0x2512a256, 0xf7ee7dc0, 0x265fcbfb, 0xf4a3146d, \
+ 0x69ad35a0, 0xbb51ea36, 0x6ae05c0d, 0xb81c839b, \
+ 0x6f37e6fa, 0xbdcb396c, 0x6c7a8f57, 0xbe8650c1, \
+ 0x64989314, 0xb6644c82, 0x67d5fab9, 0xb529252f, \
+ 0x6202404e, 0xb0fe9fd8, 0x614f29e3, 0xb3b3f675, \
+ 0x73c678c8, 0xa13aa75e, 0x708b1165, 0xa277cef3, \
+ 0x755cab92, 0xa7a07404, 0x7611c23f, 0xa4ed1da9, \
+ 0x7ef3de7c, 0xac0f01ea, 0x7dbeb7d1, 0xaf426847, \
+ 0x78690d26, 0xaa95d2b0, 0x7b24648b, 0xa9d8bb1d, \
+ 0x5d7baf70, 0x8f8770e6, 0x5e36c6dd, 0x8cca194b, \
+ 0x5be17c2a, 0x891da3bc, 0x58ac1587, 0x8a50ca11, \
+ 0x504e09c4, 0x82b2d652, 0x53036069, 0x81ffbfff, \
+ 0x56d4da9e, 0x84280508, 0x5599b333, 0x87656ca5, \
+ 0x4710e218, 0x95ec3d8e, 0x445d8bb5, 0x96a15423, \
+ 0x418a3142, 0x9376eed4, 0x42c758ef, 0x903b8779, \
+ 0x4a2544ac, 0x98d99b3a, 0x49682d01, 0x9b94f297, \
+ 0x4cbf97f6, 0x9e434860, 0x4ff2fe5b, 0x9d0e21cd, \
+ 0xd35a6b40, 0x01a6b4d6, 0xd01702ed, 0x02ebdd7b, \
+ 0xd5c0b81a, 0x073c678c, 0xd68dd1b7, 0x04710e21, \
+ 0xde6fcdf4, 0x0c931262, 0xdd22a459, 0x0fde7bcf, \
+ 0xd8f51eae, 0x0a09c138, 0xdbb87703, 0x0944a895, \
+ 0xc9312628, 0x1bcdf9be, 0xca7c4f85, 0x18809013, \
+ 0xcfabf572, 0x1d572ae4, 0xcce69cdf, 0x1e1a4349, \
+ 0xc404809c, 0x16f85f0a, 0xc749e931, 0x15b536a7, \
+ 0xc29e53c6, 0x10628c50, 0xc1d33a6b, 0x132fe5fd, \
+ 0xe78cf190, 0x35702e06, 0xe4c1983d, 0x363d47ab, \
+ 0xe11622ca, 0x33eafd5c, 0xe25b4b67, 0x30a794f1, \
+ 0xeab95724, 0x384588b2, 0xe9f43e89, 0x3b08e11f, \
+ 0xec23847e, 0x3edf5be8, 0xef6eedd3, 0x3d923245, \
+ 0xfde7bcf8, 0x2f1b636e, 0xfeaad555, 0x2c560ac3, \
+ 0xfb7d6fa2, 0x2981b034, 0xf830060f, 0x2accd999, \
+ 0xf0d21a4c, 0x222ec5da, 0xf39f73e1, 0x2163ac77, \
+ 0xf648c916, 0x24b41680, 0xf505a0bb, 0x27f97f2d, \
+ 0xbaf75ee0, 0x680b8176, 0xb9ba374d, 0x6b46e8db, \
+ 0xbc6d8dba, 0x6e91522c, 0xbf20e417, 0x6ddc3b81, \
+ 0xb7c2f854, 0x653e27c2, 0xb48f91f9, 0x66734e6f, \
+ 0xb1582b0e, 0x63a4f498, 0xb21542a3, 0x60e99d35, \
+ 0xa09c1388, 0x7260cc1e, 0xa3d17a25, 0x712da5b3, \
+ 0xa606c0d2, 0x74fa1f44, 0xa54ba97f, 0x77b776e9, \
+ 0xada9b53c, 0x7f556aaa, 0xaee4dc91, 0x7c180307, \
+ 0xab336666, 0x79cfb9f0, 0xa87e0fcb, 0x7a82d05d, \
+ 0x8e21c430, 0x5cdd1ba6, 0x8d6cad9d, 0x5f90720b, \
+ 0x88bb176a, 0x5a47c8fc, 0x8bf67ec7, 0x590aa151, \
+ 0x83146284, 0x51e8bd12, 0x80590b29, 0x52a5d4bf, \
+ 0x858eb1de, 0x57726e48, 0x86c3d873, 0x543f07e5, \
+ 0x944a8958, 0x46b656ce, 0x9707e0f5, 0x45fb3f63, \
+ 0x92d05a02, 0x402c8594, 0x919d33af, 0x4361ec39, \
+ 0x997f2fec, 0x4b83f07a, 0x9a324641, 0x48ce99d7, \
+ 0x9fe5fcb6, 0x4d192320, 0x9ca8951b, 0x4e544a8d \
+}
+
+
+typedef struct _ntapi_hashed_symbol {
+ uint32_t crc32_hash;
+ uint32_t ordinal;
+} ntapi_hashed_symbol;
+
+
+typedef uint32_t __cdecl ntapi_tt_buffer_crc32(
+ uint32_t prev_hash,
+ const void * buffer,
+ size_t size);
+
+
+typedef uint32_t __cdecl ntapi_tt_mbstr_crc32(
+ const void * str);
+
+
+typedef const uint32_t * __cdecl ntapi_tt_crc32_table(void);
+
+
+#endif
diff --git a/include/ntapi/nt_daemon.h b/include/ntapi/nt_daemon.h
new file mode 100644
index 0000000..ef9939b
--- /dev/null
+++ b/include/ntapi/nt_daemon.h
@@ -0,0 +1,89 @@
+#ifndef _NT_DAEMON_H_
+#define _NT_DAEMON_H_
+
+/**
+ * daemon start-up routines
+ * -----------------------
+ * upon successful return from dsr_init(),
+ * an LPC-based daemon will have entered its
+ * main service loop in a dedicated thread,
+ * having already established an internal
+ * connection.
+ *
+ * remarks
+ * -------
+ * 1) in the larger-scale midipix project, three
+ * different daemons are initialized using the
+ * below api, namely the optional tty server,
+ * the optional virtual mount server, and the
+ * posix system call layer internal daemon.
+ *
+ * 2) the initialization routines make use of two
+ * events: a 'damon-is-ready' event, and an
+ * 'internal-client-is-ready' event. if these
+ * events are not provided by the application
+ * then they will be created by this library,
+ * in which case each of the two handles may
+ * optionally be saved to a caller-provided
+ * address.
+ *
+ * 3) the dedicated thread of a well-designed
+ * daemon should be able to use a stack that
+ * is relatively very small; to fine-tune
+ * the stack size of the daemon's dedicated
+ * thread, use the appropriate members of
+ * the nt_daemon_params structure.
+**/
+
+#include <psxtypes/psxtypes.h>
+#include "nt_thread.h"
+#include "nt_port.h"
+
+/* NT_DSR_INIT_FLAGS */
+#define NT_DSR_INIT_DEFAULT 0x0000
+#define NT_DSR_INIT_GENERATE_KEYS 0x0001
+#define NT_DSR_INIT_FORMAT_KEYS 0x0002
+#define NT_DSR_INIT_CLOSE_EVENTS 0x0004
+
+/* daemon start: max wait: 156 seconds (twelve bonobo couples) */
+#define NT_DSR_INIT_MAX_WAIT 156 * (-1) * 10 * 1000 * 1000
+
+typedef int32_t __stdcall nt_daemon_routine(void * context);
+
+typedef struct _nt_daemon_params {
+ wchar16_t * port_name;
+ nt_port_keys * port_keys;
+ nt_port_name_keys * port_name_keys;
+ uintptr_t port_msg_size;
+ nt_daemon_routine * daemon_once_routine;
+ nt_daemon_routine * daemon_loop_routine;
+ void * daemon_loop_context;
+ void * hport_daemon;
+ void ** pport_daemon;
+ void * hport_internal_client;
+ void ** pport_internal_client;
+ void * hevent_daemon_ready;
+ void ** pevent_daemon_ready;
+ void * hevent_internal_client_ready;
+ void ** pevent_internal_client_ready;
+ void * hthread_daemon_start;
+ void * hthread_daemon_loop;
+ void * hthread_internal_client;
+ int32_t exit_code_daemon_start;
+ int32_t exit_code_daemon_loop;
+ int32_t exit_code_internal_client;
+ uint32_t flags;
+ size_t stack_size_commit;
+ size_t stack_size_reserve;
+ nt_user_stack * stack_info;
+} nt_daemon_params, nt_dsr_params;
+
+
+typedef int32_t __stdcall ntapi_dsr_init(nt_daemon_params *);
+typedef int32_t __stdcall ntapi_dsr_start(nt_daemon_params *);
+typedef int32_t __stdcall ntapi_dsr_create_port(nt_daemon_params *);
+typedef int32_t __stdcall ntapi_dsr_connect_internal_client(nt_daemon_params *);
+typedef int32_t __stdcall ntapi_dsr_internal_client_connect(nt_daemon_params *);
+typedef int32_t __stdcall ntapi_dsr_loop(void *);
+
+#endif
diff --git a/include/ntapi/nt_debug.h b/include/ntapi/nt_debug.h
new file mode 100644
index 0000000..bd07dcc
--- /dev/null
+++ b/include/ntapi/nt_debug.h
@@ -0,0 +1,37 @@
+#ifndef _NT_DEBUG_H_
+#define _NT_DEBUG_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_file.h"
+
+typedef ssize_t __cdecl ntapi_dbg_write(
+ __in void * hfile,
+ __in const void * buf,
+ __in size_t bytes);
+
+
+typedef int32_t __cdecl ntapi_dbg_fn_call(
+ __in void * hfile __optional,
+ __in char * fn_caller_name,
+ __in void * fn_callee_addr,
+ __in uintptr_t fn_ret,
+ __in ntapi_dbg_write* pfn_dbg_write __optional,
+ __in char * source __optional,
+ __in int line __optional);
+
+
+typedef int32_t __cdecl ntapi_dbg_msg(
+ __in void * hfile __optional,
+ __in char * source __optional,
+ __in int line __optional,
+ __in char * fn_caller_name,
+ __in char * fmt,
+ __in uintptr_t arg1,
+ __in uintptr_t arg2,
+ __in uintptr_t arg3,
+ __in uintptr_t arg4,
+ __in uintptr_t arg5,
+ __in uintptr_t arg6,
+ __in ntapi_dbg_write* pfn_dbg_write __optional);
+
+#endif
diff --git a/include/ntapi/nt_device.h b/include/ntapi/nt_device.h
new file mode 100644
index 0000000..ca1b4d9
--- /dev/null
+++ b/include/ntapi/nt_device.h
@@ -0,0 +1,308 @@
+#ifndef _NT_DEVICE_H_
+#define _NT_DEVICE_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+
+typedef enum _nt_device_type {
+ NT_FILE_DEVICE_8042_PORT = 0x00000027,
+ NT_FILE_DEVICE_ACPI = 0x00000032,
+ NT_FILE_DEVICE_BATTERY = 0x00000029,
+ NT_FILE_DEVICE_BEEP = 0x00000001,
+ NT_FILE_DEVICE_BUS_EXTENDER = 0x0000002a,
+ NT_FILE_DEVICE_CD_ROM = 0x00000002,
+ NT_FILE_DEVICE_CD_ROM_FILE_SYSTEM = 0x00000003,
+ NT_FILE_DEVICE_CHANGER = 0x00000030,
+ NT_FILE_DEVICE_CONTROLLER = 0x00000004,
+ NT_FILE_DEVICE_DATALINK = 0x00000005,
+ NT_FILE_DEVICE_DFS = 0x00000006,
+ NT_FILE_DEVICE_DFS_FILE_SYSTEM = 0x00000035,
+ NT_FILE_DEVICE_DFS_VOLUME = 0x00000036,
+ NT_FILE_DEVICE_DISK = 0x00000007,
+ NT_FILE_DEVICE_DISK_FILE_SYSTEM = 0x00000008,
+ NT_FILE_DEVICE_DVD = 0x00000033,
+ NT_FILE_DEVICE_FILE_SYSTEM = 0x00000009,
+ NT_FILE_DEVICE_FIPS = 0x0000003a,
+ NT_FILE_DEVICE_FULLSCREEN_VIDEO = 0x00000034,
+ NT_FILE_DEVICE_INPORT_PORT = 0x0000000a,
+ NT_FILE_DEVICE_KEYBOARD = 0x0000000b,
+ NT_FILE_DEVICE_KS = 0x0000002f,
+ NT_FILE_DEVICE_KSEC = 0x00000039,
+ NT_FILE_DEVICE_MAILSLOT = 0x0000000c,
+ NT_FILE_DEVICE_MASS_STORAGE = 0x0000002d,
+ NT_FILE_DEVICE_MIDI_IN = 0x0000000d,
+ NT_FILE_DEVICE_MIDI_OUT = 0x0000000e,
+ NT_FILE_DEVICE_MODEM = 0x0000002b,
+ NT_FILE_DEVICE_MOUSE = 0x0000000f,
+ NT_FILE_DEVICE_MULTI_UNC_PROVIDER = 0x00000010,
+ NT_FILE_DEVICE_NAMED_PIPE = 0x00000011,
+ NT_FILE_DEVICE_NETWORK = 0x00000012,
+ NT_FILE_DEVICE_NETWORK_BROWSER = 0x00000013,
+ NT_FILE_DEVICE_NETWORK_FILE_SYSTEM = 0x00000014,
+ NT_FILE_DEVICE_NETWORK_REDIRECTOR = 0x00000028,
+ NT_FILE_DEVICE_NULL = 0x00000015,
+ NT_FILE_DEVICE_PARALLEL_PORT = 0x00000016,
+ NT_FILE_DEVICE_PHYSICAL_NETCARD = 0x00000017,
+ NT_FILE_DEVICE_PRINTER = 0x00000018,
+ NT_FILE_DEVICE_SCANNER = 0x00000019,
+ NT_FILE_DEVICE_SCREEN = 0x0000001c,
+ NT_FILE_DEVICE_SERENUM = 0x00000037,
+ NT_FILE_DEVICE_SERIAL_MOUSE_PORT = 0x0000001a,
+ NT_FILE_DEVICE_SERIAL_PORT = 0x0000001b,
+ NT_FILE_DEVICE_SMARTCARD = 0x00000031,
+ NT_FILE_DEVICE_SMB = 0x0000002e,
+ NT_FILE_DEVICE_SOUND = 0x0000001d,
+ NT_FILE_DEVICE_STREAMS = 0x0000001e,
+ NT_FILE_DEVICE_TAPE = 0x0000001f,
+ NT_FILE_DEVICE_TAPE_FILE_SYSTEM = 0x00000020,
+ NT_FILE_DEVICE_TERMSRV = 0x00000038,
+ NT_FILE_DEVICE_TRANSPORT = 0x00000021,
+ NT_FILE_DEVICE_UNKNOWN = 0x00000022,
+ NT_FILE_DEVICE_VDM = 0x0000002c,
+ NT_FILE_DEVICE_VIDEO = 0x00000023,
+ NT_FILE_DEVICE_VIRTUAL_DISK = 0x00000024,
+ NT_FILE_DEVICE_WAVE_IN = 0x00000025,
+ NT_FILE_DEVICE_WAVE_OUT = 0x00000026,
+} nt_device_type;
+
+
+/* forward declaration of structures */
+struct _nt_device_object;
+struct _nt_driver_object;
+
+typedef struct _nt_list_entry {
+ struct _nt_list_entry * flink;
+ struct _nt_list_entry * blink;
+} nt_list_entry;
+
+
+typedef struct _nt_dispatcher_header {
+ int32_t lock; /* context-specific interpretations */
+ int32_t signal_state; /* context-specific interpretations */
+ nt_list_entry wait_list_head;
+} nt_dispatcher_header;
+
+
+typedef struct _nt_io_completion_context {
+ void * port;
+ void * key;
+} nt_io_completion_context;
+
+
+typedef struct _nt_fast_io_dispatch {
+ uint32_t size_of_fast_io_dispatch;
+ unsigned char * fast_io_check_if_possible;
+ unsigned char * fast_io_read;
+ unsigned char * fast_io_write;
+ unsigned char * fast_io_query_basic_info;
+ unsigned char * fast_io_query_standard_info;
+ unsigned char * fast_io_lock;
+ unsigned char * fast_io_unlock_single;
+ unsigned char * fast_io_unlock_all;
+ unsigned char * fast_io_unlock_all_by_key;
+ unsigned char * fast_io_device_control;
+ void * acquire_file_for_nt_create_section;
+ void * release_file_for_nt_create_section;
+ void * fast_io_detach_device;
+ unsigned char * fast_io_query_network_open_info;
+ int32_t acquire_for_mod_write;
+ unsigned char * mdl_read;
+ unsigned char * mdl_read_complete;
+ unsigned char * prepare_mdl_write;
+ unsigned char * mdl_write_complete;
+ unsigned char * fast_io_read_compressed;
+ unsigned char * fast_io_write_compressed;
+ unsigned char * mdl_read_complete_compressed;
+ unsigned char * mdl_write_complete_compressed;
+ unsigned char * fast_io_query_open;
+ int32_t * release_for_mod_write;
+ int32_t * acquire_for_cc_flush;
+ int32_t * release_for_cc_flush;
+} nt_fast_io_dispatch;
+
+
+typedef struct _nt_io_timer {
+ int16_t type;
+ int16_t timer_flag;
+ nt_list_entry timer_listj;
+ void * timer_routine;
+ void * context;
+ void * device_object;
+} nt_io_timer;
+
+
+typedef struct _nt_ecp_list {
+ char opaque[1];
+} nt_ecp_list;
+
+
+typedef struct _nt_txn_parameter_block {
+ uint16_t length;
+ uint16_t tx_fs_context;
+ void * transaction_object;
+} nt_txn_parameter_block;
+
+
+typedef struct _nt_io_driver_create_context {
+ uint16_t size;
+ struct _nt_ecp_list * extra_create_parameters;
+ void * device_object_hint;
+ nt_txn_parameter_block * txn_parameters;
+} nt_io_driver_create_context;
+
+
+typedef struct _nt_irp {
+ int16_t type;
+ uint16_t size;
+ struct _nt_mdl * mdl_address;
+ uint32_t flags;
+ uintptr_t associated_irp;
+ nt_list_entry thread_list_entry;
+ char requestor_mode;
+ unsigned char pending_returned;
+ char stack_count;
+ char current_location;
+ unsigned char cancel;
+ unsigned char cancel_irql;
+ char apc_environment;
+ unsigned char allocation_flags;
+ nt_io_status_block * user_iosb;
+ struct _nt_kevent * user_event;
+ void * overlay[2];
+ void * cancel_routine;
+ void * user_buffer;
+ void * tail;
+} nt_irp;
+
+
+typedef struct _nt_kdevice_queue {
+ int16_t type;
+ int16_t size;
+ struct _nt_list_entry device_list_head;
+ uint64_t lock;
+ unsigned char busy_hint[8];
+} nt_kdevice_queue;
+
+
+typedef struct _nt_kdevice_queue_entry {
+ nt_list_entry device_list_entry;
+ uint32_t sort_key;
+ unsigned char inserted;
+} nt_kdevice_queue_entry;
+
+
+typedef struct _nt_kevent {
+ struct _nt_dispatcher_header header;
+} nt_kevent;
+
+
+typedef struct _nt_kdpc {
+ unsigned char type;
+ unsigned char importance;
+ uint16_t number;
+ nt_list_entry dpc_list_entry;
+ void * deferred_routine;
+ void * deferred_context;
+ void * system_argument_1st;
+ void * system_argument_2nd;
+ void * dpc_data;
+} nt_kdpc;
+
+
+typedef struct _nt_mdl {
+ struct _nt_mdl * next;
+ int16_t size;
+ int16_t mdl_flags;
+ void * process;
+ void * mapped_system_va;
+ void * start_va;
+ uint32_t byte_count;
+ uint32_t byte_offset;
+} nt_mdl;
+
+
+typedef struct _nt_vpb {
+ int16_t type;
+ int16_t size;
+ uint16_t flags;
+ uint16_t volume_label_length;
+ struct _nt_device_object * device_object;
+ struct _nt_device_object * real_device;
+ uint32_t serial_number;
+ uint32_t reference_count;
+ wchar16_t volume_label[32];
+} nt_vpb;
+
+
+typedef struct _nt_wait_context_block {
+ struct _nt_kdevice_queue_entry wait_queue_entry;
+ void * device_routine;
+ void * device_context;
+ uint32_t number_of_map_registers;
+ void * device_object;
+ void * current_irp;
+ struct _kdpc * buffer_chaining_dpc;
+} nt_wait_context_block;
+
+
+typedef struct _nt_device_object {
+ int16_t type;
+ uint16_t size;
+ int32_t ref_count;
+ struct _nt_driver_object * driver_obj;
+ struct _nt_device_object * next_device;
+ struct _nt_device_object * attached_device;
+ struct _nt_irp * current_irp;
+ struct _nt_io_timer * timer;
+ uint32_t flags;
+ uint32_t characteristics;
+ struct _nt_vpb * vpb;
+ void * dev_ext;
+ nt_device_type dev_type;
+ char stack_size;
+
+ union {
+ struct _nt_list_entry list_entry;
+ struct _nt_wait_context_block wcb;
+ } queue;
+
+ uint32_t alignment_requirement;
+ struct _nt_kdevice_queue dev_queue;
+ struct _nt_kdpc dpc;
+ uint32_t active_thread_count;
+ nt_security_descriptor * sec_desc;
+ struct _nt_kevent dev_lock;
+ uint16_t sector_size;
+ uint16_t spare1;
+ void * device_object_extension;
+ void * reserved;
+} nt_device_object;
+
+
+typedef struct _nt_driver_object {
+ int16_t type;
+ int16_t size;
+ struct _nt_device_object * dev_obj;
+ uint32_t flags;
+ void * driver_start;
+ uint32_t driver_size;
+ void * driver_section;
+ void * driver_extension; /* TODO: define struct _nt_driver_extension (tedious) */
+ nt_unicode_string driver_name;
+ nt_unicode_string * hardware_database;
+ struct _nt_fast_io_dispatch * fast_io_dispatch;
+ int32_t * driver_init;
+ void * driver_start_io;
+ void * driver_unload;
+ void * major_function[28];
+} nt_driver_object;
+
+
+typedef int32_t __stdcall ntapi_zw_load_driver(
+ __in nt_unicode_string * driver_service_name);
+
+
+typedef int32_t __stdcall ntapi_zw_unload_driver(
+ __in nt_unicode_string * driver_service_name);
+
+#endif
diff --git a/include/ntapi/nt_exception.h b/include/ntapi/nt_exception.h
new file mode 100644
index 0000000..6284372
--- /dev/null
+++ b/include/ntapi/nt_exception.h
@@ -0,0 +1,29 @@
+#ifndef _NT_EXCEPTION_H_
+#define _NT_EXCEPTION_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+#include "nt_thread.h"
+
+/* limits */
+#define NT_EXCEPTION_MAX_PARAMS (0x0F)
+
+typedef struct _nt_exception_record {
+ uint32_t exception_code;
+ uint32_t exception_flags;
+ struct _nt_exception_record * exception_record;
+ void * exception_address;
+ uint32_t number_of_params;
+ uintptr_t exception_information[NT_EXCEPTION_MAX_PARAMS];
+} nt_exception_record;
+
+typedef int32_t __stdcall ntapi_zw_raise_exception(
+ __in nt_exception_record * exception_record,
+ __in nt_thread_context * context,
+ __in unsigned char search_frames);
+
+typedef int32_t __stdcall ntapi_zw_continue(
+ __in nt_thread_context * context,
+ __in unsigned char test_alert);
+
+#endif
diff --git a/include/ntapi/nt_file.h b/include/ntapi/nt_file.h
new file mode 100644
index 0000000..3bdd085
--- /dev/null
+++ b/include/ntapi/nt_file.h
@@ -0,0 +1,1206 @@
+#ifndef _NT_FILE_H_
+#define _NT_FILE_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+#include "nt_device.h"
+
+typedef enum _nt_file_info_class {
+ NT_FILE_DIRECTORY_INFORMATION = 1,
+ NT_FILE_FULL_DIRECTORY_INFORMATION = 2,
+ NT_FILE_BOTH_DIRECTORY_INFORMATION = 3,
+ NT_FILE_BASIC_INFORMATION = 4,
+ NT_FILE_STANDARD_INFORMATION = 5,
+ NT_FILE_INTERNAL_INFORMATION = 6,
+ NT_FILE_EA_INFORMATION = 7,
+ NT_FILE_ACCESS_INFORMATION = 8,
+ NT_FILE_NAME_INFORMATION = 9,
+ NT_FILE_RENAME_INFORMATION = 10,
+ NT_FILE_LINK_INFORMATION = 11,
+ NT_FILE_NAMES_INFORMATION = 12,
+ NT_FILE_DISPOSITION_INFORMATION = 13,
+ NT_FILE_POSITION_INFORMATION = 14,
+ NT_FILE_FULL_EA_INFORMATION = 15,
+ NT_FILE_MODE_INFORMATION = 16,
+ NT_FILE_ALIGNMENT_INFORMATION = 17,
+ NT_FILE_ALL_INFORMATION = 18,
+ NT_FILE_ALLOCATION_INFORMATION = 19,
+ NT_FILE_END_OF_FILE_INFORMATION = 20,
+ NT_FILE_ALTERNATE_NAME_INFORMATION = 21,
+ NT_FILE_STREAM_INFORMATION = 22,
+ NT_FILE_PIPE_INFORMATION = 23,
+ NT_FILE_PIPE_LOCAL_INFORMATION = 24,
+ NT_FILE_PIPE_REMOTE_INFORMATION = 25,
+ NT_FILE_MAILSLOT_QUERY_INFORMATION = 26,
+ NT_FILE_MAILSLOT_SET_INFORMATION = 27,
+ NT_FILE_COMPRESSION_INFORMATION = 28,
+ NT_FILE_OBJECT_ID_INFORMATION = 29,
+ NT_FILE_COMPLETION_INFORMATION = 30,
+ NT_FILE_MOVE_CLUSTER_INFORMATION = 31,
+ NT_FILE_QUOTA_INFORMATION = 32,
+ NT_FILE_REPARSE_POINT_INFORMATION = 33,
+ NT_FILE_NETWORK_OPEN_INFORMATION = 34,
+ NT_FILE_ATTRIBUTE_TAG_INFORMATION = 35,
+ NT_FILE_TRACKING_INFORMATION = 36,
+ NT_FILE_ID_BOTH_DIRECTORY_INFORMATION = 37,
+ NT_FILE_ID_FULL_DIRECTORY_INFORMATION = 38,
+ NT_FILE_VALID_DATA_LENGTH_INFORMATION = 39,
+ NT_FILE_SHORT_NAME_INFORMATION = 40,
+ NT_FILE_IO_COMPLETION_NOTIFICATION_INFORMATION = 41,
+ NT_FILE_IO_STATUS_BLOCK_RANGE_INFORMATION = 42,
+ NT_FILE_IO_PRIORITY_HINT_INFORMATION = 43,
+ NT_FILE_SFIO_RESERVE_INFORMATION = 44,
+ NT_FILE_SFIO_VOLUME_INFORMATION = 45,
+ NT_FILE_HARD_LINK_INFORMATION = 46,
+ NT_FILE_PROCESS_IDS_USING_FILE_INFORMATION = 47,
+ NT_FILE_NORMALIZED_NAME_INFORMATION = 48,
+ NT_FILE_NETWORK_PHYSICAL_NAME_INFORMATION = 49,
+ NT_FILE_ID_GLOBAL_TX_DIRECTORY_INFORMATION = 50,
+ NT_FILE_IS_REMOTE_DEVICE_INFORMATION = 51,
+ NT_FILE_ATTRIBUTE_CACHE_INFORMATION = 52,
+ NT_FILE_NUMA_NODE_INFORMATION = 53,
+ NT_FILE_STANDARD_LINK_INFORMATION = 54,
+ NT_FILE_REMOTE_PROTOCOL_INFORMATION = 55,
+ NT_FILE_REPLACE_COMPLETION_INFORMATION = 56,
+ NT_FILE_INFORMATION_CAP = 57
+} nt_file_info_class;
+
+
+typedef enum _nt_file_create_disposition {
+ NT_FILE_SUPERSEDE = 0x00000000,
+ NT_FILE_OPEN = 0x00000001,
+ NT_FILE_CREATE = 0x00000002,
+ NT_FILE_OPEN_IF = 0x00000003,
+ NT_FILE_OVERWRITE = 0x00000004,
+ NT_FILE_OVERWRITE_IF = 0x00000005
+} nt_file_create_disposition;
+
+
+typedef enum _nt_file_status {
+ NT_FILE_SUPERSEDED = 0x00000000,
+ NT_FILE_OPENED = 0x00000001,
+ NT_FILE_CREATED = 0x00000002,
+ NT_FILE_OVERWRITTEN = 0x00000003,
+ NT_FILE_EXISTS = 0x00000004,
+ NT_FILE_DOES_NOT_EXIST = 0x00000005
+} nt_file_status;
+
+
+typedef enum _nt_file_action {
+ NT_FILE_ACTION_ADDED = 0x00000001,
+ NT_FILE_ACTION_REMOVED = 0x00000002,
+ NT_FILE_ACTION_MODIFIED = 0x00000003,
+ NT_FILE_ACTION_RENAMED_OLD_NAME = 0x00000004,
+ NT_FILE_ACTION_RENAMED_NEW_NAME = 0x00000005,
+ NT_FILE_ACTION_ADDED_STREAM = 0x00000006,
+ NT_FILE_ACTION_REMOVED_STREAM = 0x00000007,
+ NT_FILE_ACTION_MODIFIED_STREAM = 0x00000008,
+ NT_FILE_ACTION_REMOVED_BY_DELETE = 0x00000009,
+} nt_file_action;
+
+
+typedef enum _nt_file_pipe_flags {
+ NT_FILE_PIPE_BYTE_STREAM_MODE = 0x00000000,
+ NT_FILE_PIPE_MESSAGE_MODE = 0x00000001,
+
+ NT_FILE_PIPE_QUEUE_OPERATION = 0x00000000,
+ NT_FILE_PIPE_COMPLETE_OPERATION = 0x00000001,
+
+ NT_FILE_PIPE_BYTE_STREAM_TYPE = 0x00000000,
+ NT_FILE_PIPE_MESSAGE_TYPE = 0x00000001,
+
+ NT_FILE_PIPE_INBOUND = 0x00000000,
+ NT_FILE_PIPE_OUTBOUND = 0x00000001,
+ NT_FILE_PIPE_FULL_DUPLEX = 0x00000002,
+
+ NT_FILE_PIPE_DISCONNECTED_STATE = 0x00000001,
+ NT_FILE_PIPE_LISTENING_STATE = 0x00000002,
+ NT_FILE_PIPE_CONNECTED_STATE = 0x00000003,
+ NT_FILE_PIPE_CLOSING_STATE = 0x00000004,
+
+ NT_FILE_PIPE_CLIENT_END = 0x00000000,
+ NT_FILE_PIPE_SERVER_END = 0x00000001,
+} nt_file_pipe_flags;
+
+
+typedef enum _nt_io_priority_hint {
+ NT_IO_PRIORITY_VERY_LOW = 0,
+ NT_IO_PRIORITY_LOW = 1,
+ NT_IO_PRIORITY_NORMAL = 2,
+ NT_IO_PRIORITY_HIGH = 3,
+ NT_IO_PRIORITY_CRITICAL = 4,
+ NT_MAX_IO_PRIORITY_TYPES = 5
+} nt_io_priority_hint;
+
+
+typedef enum _nt_fs_info_class {
+ NT_FILE_FS_VOLUME_INFORMATION = 1,
+ NT_FILE_FS_LABEL_INFORMATION = 2,
+ NT_FILE_FS_SIZE_INFORMATION = 3,
+ NT_FILE_FS_DEVICE_INFORMATION = 4,
+ NT_FILE_FS_ATTRIBUTE_INFORMATION = 5,
+ NT_FILE_FS_CONTROL_INFORMATION = 6,
+ NT_FILE_FS_FULL_SIZE_INFORMATION = 7,
+ NT_FILE_FS_OBJECT_ID_INFORMATION = 8,
+ NT_FILE_FS_DRIVER_PATH_INFORMATION = 9,
+ NT_FILE_FS_VOLUME_FLAGS_INFORMATION = 10,
+ NT_FILE_FS_SECTOR_SIZE_INFORMATION = 11,
+} nt_fs_info_class;
+
+
+/* file attributes */
+#define NT_FILE_ATTRIBUTE_READONLY 0x00000001
+#define NT_FILE_ATTRIBUTE_HIDDEN 0x00000002
+#define NT_FILE_ATTRIBUTE_SYSTEM 0x00000004
+#define NT_FILE_ATTRIBUTE_DIRECTORY 0x00000010
+#define NT_FILE_ATTRIBUTE_ARCHIVE 0x00000020
+#define NT_FILE_ATTRIBUTE_DEVICE 0x00000040
+#define NT_FILE_ATTRIBUTE_NORMAL 0x00000080
+#define NT_FILE_ATTRIBUTE_TEMPORARY 0x00000100
+#define NT_FILE_ATTRIBUTE_SPARSE_FILE 0x00000200
+#define NT_FILE_ATTRIBUTE_REPARSE_POINT 0x00000400
+#define NT_FILE_ATTRIBUTE_COMPRESSED 0x00000800
+#define NT_FILE_ATTRIBUTE_OFFLINE 0x00001000
+#define NT_FILE_ATTRIBUTE_NOT_CONTENT_INDEXED 0x00002000
+#define NT_FILE_ATTRIBUTE_ENCRYPTED 0x00004000
+#define NT_FILE_ATTRIBUTE_INTEGRITY_STREAM 0x00008000
+#define NT_FILE_ATTRIBUTE_VIRTUAL 0x00010000
+#define NT_FILE_ATTRIBUTE_NO_SCRUB_DATA 0x00020000
+
+
+/* file create options */
+#define NT_FILE_ASYNCHRONOUS_IO 0x00000000
+#define NT_FILE_DIRECTORY_FILE 0x00000001
+#define NT_FILE_WRITE_THROUGH 0x00000002
+#define NT_FILE_SEQUENTIAL_ONLY 0x00000004
+#define NT_FILE_NO_INTERMEDIATE_BUFFERING 0x00000008
+#define NT_FILE_SYNCHRONOUS_IO_ALERT 0x00000010
+#define NT_FILE_SYNCHRONOUS_IO_NONALERT 0x00000020
+#define NT_FILE_NON_DIRECTORY_FILE 0x00000040
+#define NT_FILE_CREATE_TREE_CONNECTION 0x00000080
+#define NT_FILE_COMPLETE_IF_OPLOCKED 0x00000100
+#define NT_FILE_NO_EA_KNOWLEDGE 0x00000200
+#define NT_FILE_OPEN_REMOTE_INSTANCE 0x00000400
+#define NT_FILE_RANDOM_ACCESS 0x00000800
+#define NT_FILE_DELETE_ON_CLOSE 0x00001000
+#define NT_FILE_OPEN_BY_FILE_ID 0x00002000
+#define NT_FILE_OPEN_FOR_BACKUP_INTENT 0x00004000
+#define NT_FILE_NO_COMPRESSION 0x00008000
+#define NT_FILE_SESSION_AWARE 0x00040000
+#define NT_FILE_RESERVE_OPFILTER 0x00100000
+#define NT_FILE_OPEN_REPARSE_POINT 0x00200000
+#define NT_FILE_OPEN_NO_RECALL 0x00400000
+#define NT_FILE_OPEN_FOR_FREE_SPACE_QUERY 0x00800000
+
+
+/* file share access */
+#define NT_FILE_SHARE_READ 0x00000001
+#define NT_FILE_SHARE_WRITE 0x00000002
+#define NT_FILE_SHARE_DELETE 0x00000004
+
+
+/* file notify */
+#define NT_FILE_NOTIFY_CHANGE_FILE_NAME 0x00000001
+#define NT_FILE_NOTIFY_CHANGE_DIR_NAME 0x00000002
+#define NT_FILE_NOTIFY_CHANGE_ATTRIBUTES 0x00000004
+#define NT_FILE_NOTIFY_CHANGE_SIZE 0x00000008
+#define NT_FILE_NOTIFY_CHANGE_LAST_WRITE 0x00000010
+#define NT_FILE_NOTIFY_CHANGE_LAST_ACCESS 0x00000020
+#define NT_FILE_NOTIFY_CHANGE_CREATION 0x00000040
+#define NT_FILE_NOTIFY_CHANGE_EA 0x00000040
+#define NT_FILE_NOTIFY_CHANGE_SECURITY 0x00000100
+#define NT_FILE_NOTIFY_CHANGE_STREAM_NAME 0x00000100
+#define NT_FILE_NOTIFY_CHANGE_STREAM_SIZE 0x00000100
+#define NT_FILE_NOTIFY_CHANGE_STREAM_WRITE 0x00000100
+
+
+/* file system flags */
+#define NT_FILE_CASE_SENSITIVE_SEARCH 0x00000001
+#define NT_FILE_CASE_PRESERVED_NAMES 0x00000002
+#define NT_FILE_UNICODE_ON_DISK 0x00000004
+#define NT_FILE_PERSISTENT_ACLS 0x00000008
+#define NT_FILE_FILE_COMPRESSION 0x00000010
+#define NT_FILE_VOLUME_QUOTAS 0x00000020
+#define NT_FILE_SUPPORTS_SPARSE_FILES 0x00000040
+#define NT_FILE_SUPPORTS_REPARSE_POINTS 0x00000080
+#define NT_FILE_SUPPORTS_REMOTE_STORAGE 0x00000100
+#define NT_FILE_VOLUME_IS_COMPRESSED 0x00008000
+#define NT_FILE_SUPPORTS_OBJECT_IDS 0x00010000
+#define NT_FILE_SUPPORTS_ENCRYPTION 0x00020000
+#define NT_FILE_NAMED_STREAMS 0x00040000
+#define NT_FILE_READ_ONLY_VOLUME 0x00080000
+#define NT_FILE_SEQUENTIAL_WRITE_ONCE 0x00100000
+#define NT_FILE_SUPPORTS_TRANSACTIONS 0x00200000
+#define NT_FILE_SUPPORTS_HARD_LINKS 0x00400000
+#define NT_FILE_SUPPORTS_EXTENDED_ATTRIBUTES 0x00800000
+#define NT_FILE_SUPPORTS_OPEN_BY_FILE_ID 0x01000000
+#define NT_FILE_SUPPORTS_USN_JOURNAL 0x02000000
+#define NT_FILE_SUPPORT_INTEGRITY_STREAMS 0x04000000
+
+
+/* file sector size flags */
+#define NT_SSINFO_FLAGS_ALIGNED_DEVICE 0x00000001
+#define NT_SSINFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE 0x00000002
+#define NT_SSINFO_FLAGS_NO_SEEK_PENALTY 0x00000004
+#define NT_SSINFO_FLAGS_TRIM_ENABLED 0x00000008
+
+
+/* file alignment flags */
+#define NT_FILE_BYTE_ALIGNMENT 0x00000000
+#define NT_FILE_WORD_ALIGNMENT 0x00000001
+#define NT_FILE_LONG_ALIGNMENT 0x00000003
+#define NT_FILE_QUAD_ALIGNMENT 0x00000007
+#define NT_FILE_OCTA_ALIGNMENT 0x0000000f
+#define NT_FILE_32_BYTE_ALIGNMENT 0x0000001f
+#define NT_FILE_64_BYTE_ALIGNMENT 0x0000003f
+#define NT_FILE_128_BYTE_ALIGNMENT 0x0000007f
+#define NT_FILE_256_BYTE_ALIGNMENT 0x000000ff
+#define NT_FILE_512_BYTE_ALIGNMENT 0x000001ff
+
+
+/* file tx info flags */
+#define NT_FILE_ID_GLOBAL_TX_DIR_INFO_FLAG_WRITELOCKED 0x00000001
+#define NT_FILE_ID_GLOBAL_TX_DIR_INFO_FLAG_VISIBLE_TO_TX 0x00000002
+#define NT_FILE_ID_GLOBAL_TX_DIR_INFO_FLAG_VISIBLE_OUTSIDE_TX 0x00000004
+
+
+/* friendly file type bits */
+#define NT_FILE_TYPE_UNKNOWN (0x0000u)
+#define NT_FILE_TYPE_FILE (0x0001u)
+#define NT_FILE_TYPE_DIRECTORY (0x0002u)
+#define NT_FILE_TYPE_PIPE (0x0004u)
+#define NT_FILE_TYPE_SOCKET (0x0008u)
+#define NT_FILE_TYPE_MAILSLOT (0x0010u)
+#define NT_FILE_TYPE_CSRSS (0x0020u)
+#define NT_FILE_TYPE_PTY (0x0040u)
+#define NT_FILE_TYPE_VFD (0x0080u)
+
+
+/* file access bits */
+#define NT_FILE_ANY_ACCESS (0x0000u)
+#define NT_FILE_READ_ACCESS (0x0001u)
+#define NT_FILE_READ_DATA (0x0001u)
+#define NT_FILE_LIST_DIRECTORY (0x0001u)
+#define NT_FILE_WRITE_ACCESS (0x0002u)
+#define NT_FILE_WRITE_DATA (0x0002u)
+#define NT_FILE_ADD_FILE (0x0002u)
+#define NT_FILE_APPEND_DATA (0x0004u)
+#define NT_FILE_ADD_SUBDIRECTORY (0x0004u)
+#define NT_FILE_CREATE_PIPE_INSTANCE (0x0004u)
+#define NT_FILE_READ_EA (0x0008u)
+#define NT_FILE_WRITE_EA (0x0010u)
+#define NT_FILE_EXECUTE (0x0020u)
+#define NT_FILE_TRAVERSE (0x0020u)
+#define NT_FILE_DELETE_CHILD (0x0040u)
+#define NT_FILE_READ_ATTRIBUTES (0x0080u)
+#define NT_FILE_WRITE_ATTRIBUTES (0x0100u)
+
+#define NT_FILE_ALL_ACCESS NT_FILE_ANY_ACCESS \
+ | NT_FILE_READ_ACCESS \
+ | NT_FILE_WRITE_ACCESS \
+ | NT_FILE_APPEND_DATA \
+ | NT_FILE_READ_EA \
+ | NT_FILE_WRITE_EA \
+ | NT_FILE_EXECUTE \
+ | NT_FILE_TRAVERSE \
+ | NT_FILE_DELETE_CHILD \
+ | NT_FILE_READ_ATTRIBUTES \
+ | NT_FILE_WRITE_ATTRIBUTES \
+ | NT_SEC_SYNCHRONIZE \
+ | NT_SEC_STANDARD_RIGHTS_ALL
+
+
+/* structures related to nt_fs_info_class */
+typedef struct _nt_file_fs_volume_information {
+ nt_large_integer volume_creation_time;
+ uint32_t volume_serial_number;
+ uint32_t volume_label_length;
+ unsigned char supports_objects ;
+ unsigned char reserved;
+ wchar16_t volume_label[];
+} nt_file_fs_volume_information, nt_fsvi;
+
+
+typedef struct _nt_file_fs_label_information {
+ uint32_t volume_label_length;
+ wchar16_t volume_label[];
+} nt_file_fs_label_information;
+
+
+typedef struct _nt_file_fs_size_information {
+ nt_large_integer total_allocation_units;
+ nt_large_integer available_allocation_units;
+ uint32_t sectors_per_allocation_unit;
+ uint32_t bytes_per_sector;
+} nt_file_fs_size_information, nt_fssi;
+
+
+typedef struct _nt_file_fs_device_information {
+ nt_device_type device_type;
+ uint32_t characteristics;
+} nt_file_fs_device_information, nt_fsdi;
+
+
+typedef struct _nt_file_fs_attribute_information {
+ uint32_t file_system_attributes;
+ uint32_t maximum_component_name_length;
+ uint32_t file_system_name_length;
+ wchar16_t file_system_name[];
+} nt_file_fs_attribute_information, nt_fsai;
+
+
+typedef struct _nt_file_fs_control_information {
+ nt_large_integer free_space_start_filtering;
+ nt_large_integer free_space_threshold;
+ nt_large_integer free_space_stop_filtering;
+ nt_large_integer default_quota_threshold;
+ nt_large_integer default_quota_limit;
+ uint32_t file_system_control_flags;
+ uint32_t padding;
+} nt_file_fs_control_information, nt_fsci;
+
+
+typedef struct _nt_file_fs_full_size_information {
+ nt_large_integer total_allocation_units;
+ nt_large_integer caller_available_allocation_units;
+ nt_large_integer actual_available_allocation_units;
+ uint32_t sectors_per_allocation_unit;
+ uint32_t bytes_per_sector;
+} nt_file_fs_full_size_information, nt_fsfsi;
+
+
+typedef struct _nt_file_fs_object_id_information {
+ nt_uuid volume_object_id;
+ uint32_t volume_object_id_extended_info;
+} nt_file_fs_object_id_information, nt_fsoii;
+
+
+typedef struct _nt_file_fs_driver_path_information {
+ unsigned char driver_in_path;
+ unsigned char reserved[3];
+ uint32_t driver_name_length;
+ wchar16_t driver_name[];
+} nt_file_fs_driver_path_information, nt_fsdpi;
+
+
+typedef struct _nt_file_fs_sector_size_information {
+ uint32_t logical_bytes_per_sector;
+ uint32_t physical_bytes_per_sector_for_atomicity;
+ uint32_t physical_bytes_per_sector_for_performance;
+ uint32_t effective_physical_bytes_per_sector_for_atomicity;
+ uint32_t flags;
+ uint32_t byte_offset_for_sector_alignment;
+ uint32_t byte_offset_for_partition_alignment;
+} nt_file_fs_sector_size_information, nt_fsssi;
+
+
+typedef struct _nt_file_fs_persistent_volume_information {
+ uint32_t volume_flags;
+ uint32_t flag_mask;
+ uint32_t version;
+ uint32_t reserved;
+} nt_file_fs_persistent_volume_information;
+
+
+/* structures related to zw_query_quota_information_file */
+typedef struct _nt_file_user_quota_information {
+ uint32_t next_entry_offset;
+ uint32_t sid_length;
+ nt_large_integer change_time;
+ nt_large_integer quota_used;
+ nt_large_integer quota_threshold;
+ nt_large_integer quota_limit;
+ nt_sid sid[];
+} nt_file_user_quota_information;
+
+
+typedef struct _nt_file_quota_list_information {
+ uint32_t next_entry_offset;
+ uint32_t sid_length;
+ nt_sid sid[];
+} nt_file_quota_list_information;
+
+
+
+/* structures included in nt_file_all_information */
+typedef struct _nt_file_basic_information {
+ nt_large_integer creation_time;
+ nt_large_integer last_access_time;
+ nt_large_integer last_write_time;
+ nt_large_integer change_time;
+ uint32_t file_attr;
+} nt_file_basic_information, nt_fbi;
+
+
+typedef struct _nt_file_standard_information {
+ nt_large_integer allocation_size;
+ nt_large_integer end_of_file;
+ uint32_t number_of_links;
+ unsigned char delete_pending;
+ unsigned char directory;
+ unsigned char reserved[2];
+} nt_file_standard_information, nt_fsi;
+
+
+typedef struct _nt_file_internal_information {
+ nt_large_integer index_number;
+} nt_file_internal_information, nt_fii;
+
+
+typedef struct _nt_file_ea_information {
+ uint32_t ea_size;
+} nt_file_ea_information, nt_fei;
+
+
+typedef struct _nt_file_access_information {
+ uint32_t access_flags;
+} nt_file_access_information, nt_facci;
+
+
+typedef struct _nt_file_position_information {
+ nt_large_integer current_byte_offset;
+} nt_file_position_information, nt_fpi;
+
+
+typedef struct _nt_file_mode_information {
+ uint32_t mode;
+} nt_file_mode_information, nt_fmi;
+
+
+typedef struct _nt_file_alignment_information {
+ uint32_t alignment_requirement;
+} nt_file_alignment_information, nt_falii;
+
+
+typedef struct _nt_file_name_information {
+ uint32_t file_name_length;
+ wchar16_t file_name[];
+} nt_file_name_information, nt_fni;
+
+
+typedef struct _nt_file_all_information {
+ nt_file_basic_information basic_info;
+ nt_file_standard_information standard_info;
+ nt_file_internal_information internal_info;
+ nt_file_ea_information ea_info;
+ nt_file_access_information access_info;
+ nt_file_position_information position_info;
+ nt_file_mode_information mode_info;
+ nt_file_alignment_information alignment_info;
+ nt_file_name_information name_info;
+} nt_file_all_information, nt_fai;
+
+
+
+/* structures related to nt_file_info_class */
+typedef struct _nt_file_directory_information {
+ uint32_t next_entry_offset;
+ uint32_t file_index;
+ nt_large_integer creation_time;
+ nt_large_integer last_access_time;
+ nt_large_integer last_write_time;
+ nt_large_integer change_time;
+ nt_large_integer end_of_file;
+ nt_large_integer allocation_size;
+ uint32_t file_attributes;
+ uint32_t file_name_length;
+ wchar16_t file_name[];
+} nt_file_directory_information, nt_fdiri;
+
+
+typedef struct _nt_file_full_dir_information {
+ uint32_t next_entry_offset;
+ uint32_t file_index;
+ nt_large_integer creation_time;
+ nt_large_integer last_access_time;
+ nt_large_integer last_write_time;
+ nt_large_integer change_time;
+ nt_large_integer end_of_file;
+ nt_large_integer allocation_size;
+ uint32_t file_attributes;
+ uint32_t file_name_length;
+ uint32_t ea_size;
+ wchar16_t file_name[];
+} nt_file_full_dir_information;
+
+
+typedef struct _nt_file_both_dir_information {
+ uint32_t next_entry_offset;
+ uint32_t file_index;
+ nt_large_integer creation_time;
+ nt_large_integer last_access_time;
+ nt_large_integer last_write_time;
+ nt_large_integer change_time;
+ nt_large_integer end_of_file;
+ nt_large_integer allocation_size;
+ uint32_t file_attributes;
+ uint32_t file_name_length;
+ uint32_t ea_size;
+ char short_name_length;
+ char reserved;
+ wchar16_t short_name[12];
+ wchar16_t file_name[];
+} nt_file_both_dir_information;
+
+
+typedef struct _nt_file_rename_information {
+ unsigned char replace_if_exists;
+ void * root_directory;
+ uint32_t file_name_length;
+ wchar16_t file_name[];
+} nt_file_rename_information, nt_frni;
+
+
+typedef struct _nt_file_link_information {
+ unsigned char replace_if_exists;
+ void * root_directory;
+ uint32_t file_name_length;
+ wchar16_t file_name[];
+} nt_file_link_information;
+
+
+typedef struct _nt_file_names_information {
+ uint32_t next_entry_offset;
+ uint32_t file_index;
+ uint32_t file_name_length;
+ wchar16_t file_name[];
+} nt_file_names_information, nt_fnamesi;
+
+
+typedef struct _nt_file_disposition_information {
+ unsigned char delete_file;
+} nt_file_disposition_information, nt_fdi;
+
+
+typedef struct _nt_file_full_ea_information {
+ uint32_t next_entry_offset;
+ unsigned char flags;
+ unsigned char ea_name_length;
+ uint16_t ea_value_length;
+ char ea_name[];
+} nt_file_full_ea_information;
+
+
+typedef struct _nt_file_allocation_information {
+ nt_large_integer allocation_size;
+} nt_file_allocation_information;
+
+
+typedef struct _nt_file_end_of_file_information {
+ nt_large_integer end_of_file;
+} nt_file_end_of_file_information, nt_eof;
+
+
+typedef struct _nt_file_stream_information {
+ uint32_t next_entry_offset;
+ uint32_t stream_name_length;
+ nt_large_integer stream_size;
+ nt_large_integer stream_allocation_size;
+ wchar16_t stream_name[];
+} nt_file_stream_information;
+
+
+typedef struct _nt_file_pipe_information {
+ uint32_t read_mode;
+ uint32_t completion_mode;
+} nt_file_pipe_information;
+
+
+typedef struct _nt_file_pipe_local_information {
+ uint32_t named_pipe_type;
+ uint32_t named_pipe_configuration;
+ uint32_t maximum_instances;
+ uint32_t current_instances;
+ uint32_t inbound_quota;
+ uint32_t read_data_available;
+ uint32_t outbound_quota;
+ uint32_t write_quota_available;
+ uint32_t named_pipe_state;
+ uint32_t named_pipe_end;
+} nt_file_pipe_local_information;
+
+
+typedef struct _nt_file_pipe_remote_information {
+ nt_large_integer collect_data_time;
+ uint32_t maximum_collection_count;
+} nt_file_pipe_remote_information;
+
+
+typedef struct _nt_file_mailslot_query_information {
+ uint32_t maximum_message_size;
+ uint32_t mailslot_quota;
+ uint32_t next_message_size;
+ uint32_t messages_available;
+ nt_large_integer read_timeout;
+} nt_file_mailslot_query_information;
+
+
+typedef struct _nt_file_mailslot_set_information {
+ nt_large_integer * read_timeout;
+} nt_file_mailslot_set_information;
+
+
+typedef struct _nt_file_compression_information {
+ nt_large_integer CompressedFileSize;
+ uint16_t CompressionFormat;
+ unsigned char CompressionUnitShift;
+ unsigned char ChunkShift;
+ unsigned char ClusterShift;
+ unsigned char Reserved[3];
+} nt_file_compression_information;
+
+
+typedef struct _nt_file_object_id_buffer {
+ unsigned char obj_id[16];
+ unsigned char birth_volume_id[16];
+ unsigned char birth_object_id[16];
+ unsigned char domain_id[16];
+} nt_file_object_id_buffer;
+
+
+typedef struct _nt_file_object_id_information {
+ int64_t file_reference;
+ unsigned char object_id[16];
+
+ union {
+ struct {
+ unsigned char birth_volume_id[16];
+ unsigned char birth_object_id[16];
+ unsigned char domain_id[16];
+ };
+ unsigned char extended_info[48];
+ };
+} nt_file_object_id_information;
+
+
+typedef struct _nt_file_quota_information {
+ uint32_t next_entry_offset;
+ uint32_t sid_length;
+ nt_large_integer change_time;
+ nt_large_integer quota_used;
+ nt_large_integer quota_threshold;
+ nt_large_integer quota_limit;
+ nt_sid sid;
+} nt_file_quota_information;
+
+
+typedef struct _nt_file_reparse_point_information {
+ int64_t file_reference;
+ uint32_t tag;
+} nt_file_reparse_point_information, nt_frpi;
+
+
+typedef struct _nt_file_network_open_information {
+ nt_large_integer creation_time;
+ nt_large_integer last_access_time;
+ nt_large_integer last_write_time;
+ nt_large_integer change_time;
+ nt_large_integer allocation_size;
+ nt_large_integer end_of_file;
+ uint32_t file_attributes;
+} nt_file_network_open_information;
+
+
+typedef struct _nt_file_attribute_tag_information {
+ uint32_t file_attr;
+ uint32_t reparse_tag;
+} nt_file_attribute_tag_information, nt_ftagi;
+
+
+typedef struct _nt_file_id_both_dir_information {
+ uint32_t next_entry_offset;
+ uint32_t file_index;
+ nt_large_integer creation_time;
+ nt_large_integer last_access_time;
+ nt_large_integer last_write_time;
+ nt_large_integer change_time;
+ nt_large_integer end_of_file;
+ nt_large_integer allocation_size;
+ uint32_t file_attributes;
+ uint32_t file_name_length;
+ uint32_t ea_size;
+ char short_name_length;
+ char reserved;
+ wchar16_t short_name[12];
+ nt_large_integer file_id;
+ wchar16_t file_name[];
+} nt_file_id_both_dir_information, nt_fsdirent;
+
+
+typedef struct _nt_file_id_full_dir_information {
+ uint32_t next_entry_offset;
+ uint32_t file_index;
+ nt_large_integer creation_time;
+ nt_large_integer last_access_time;
+ nt_large_integer last_write_time;
+ nt_large_integer change_time;
+ nt_large_integer end_of_file;
+ nt_large_integer allocation_size;
+ uint32_t file_attributes;
+ uint32_t file_name_length;
+ uint32_t ea_size;
+ nt_large_integer FileId;
+ wchar16_t file_name[];
+} nt_file_id_full_dir_information;
+
+
+typedef struct _nt_file_valid_data_length_information {
+ nt_large_integer valid_data_length;
+} nt_file_valid_data_length_information;
+
+
+typedef struct _nt_file_io_priority_hint_information {
+ nt_io_priority_hint priority_hint;
+} nt_file_io_priority_hint_information;
+
+
+typedef struct _nt_file_link_entry_information {
+ uint32_t next_entry_offset;
+ int64_t parent_file_id;
+ uint32_t file_name_length;
+ wchar16_t file_name[];
+} nt_file_link_entry_information;
+
+
+typedef struct _nt_file_links_information {
+ uint32_t bytes_needed;
+ uint32_t entries_returned;
+ nt_file_link_entry_information entry;
+} nt_file_links_information;
+
+
+typedef struct _nt_file_id_global_tx_dir_information {
+ uint32_t next_entry_offset;
+ uint32_t file_index;
+ nt_large_integer creation_time;
+ nt_large_integer last_access_time;
+ nt_large_integer last_write_time;
+ nt_large_integer change_time;
+ nt_large_integer end_of_file;
+ nt_large_integer allocation_size;
+ uint32_t file_attributes;
+ uint32_t file_name_length;
+ nt_large_integer file_id;
+ nt_guid locking_transaction_id;
+ uint32_t tx_info_flags;
+ wchar16_t file_name[];
+} nt_file_id_global_tx_dir_information;
+
+
+typedef struct _nt_file_completion_information {
+ void * port;
+ void * key;
+} nt_file_completion_information;
+
+
+
+/* file extended attributes */
+typedef struct _nt_file_get_ea_information {
+ uint32_t next_entry_offset;
+ unsigned char ea_name_length;
+ char ea_name[];
+} nt_file_get_ea_information;
+
+
+/* quota information */
+typedef struct _nt_file_get_quota_information {
+ uint32_t next_entry_offset;
+ uint32_t sid_length;
+ nt_sid sid;
+} nt_file_get_quota_information;
+
+
+/* file change notification */
+typedef struct _nt_file_notify_information {
+ uint32_t next_entry_offset;
+ uint32_t action;
+ uint32_t file_name_length;
+ wchar16_t file_name[];
+} nt_file_notify_information;
+
+
+/* file segment element */
+typedef union _nt_file_segment_element {
+ uint64_t * buffer;
+ uint64_t alignment;
+} nt_file_segment_element;
+
+
+/* section object pointers */
+typedef struct _nt_section_object_pointers {
+ void * data_section_object;
+ void * shared_cache_map;
+ void * image_section_object;
+} nt_section_object_pointers;
+
+
+/* reparse guid data buffer */
+typedef struct _nt_reparse_guid_data_buffer {
+ uint32_t reparse_tag;
+ uint16_t reparse_data_length;
+ uint16_t reserved;
+ nt_guid reparse_guid;
+ unsigned char generic_reparse_buffer[];
+} nt_reparse_guid_data_buffer;
+
+
+/* reparse data buffer */
+typedef struct _nt_reparse_data_buffer {
+ uint32_t reparse_tag;
+ uint16_t reparse_data_length;
+ uint16_t reserved;
+
+ union {
+ struct {
+ uint16_t substitute_name_offset;
+ uint16_t substitute_name_length;
+ uint16_t print_name_offset;
+ uint16_t print_name_length;
+ uint32_t flags;
+ } symbolic_link_reparse_buffer;
+
+ struct {
+ uint16_t substitute_name_offset;
+ uint16_t substitute_name_length;
+ uint16_t print_name_offset;
+ uint16_t print_name_length;
+ } mount_point_reparse_buffer;
+ };
+
+ wchar16_t path_buffer[];
+} nt_reparse_data_buffer;
+
+
+/* file object */
+typedef struct _nt_file_object {
+ int16_t type;
+ int16_t size;
+ nt_device_object * dev_obj;
+ nt_vpb vpb;
+ void * fs_context;
+ void * fs_context_2nd;
+ nt_section_object_pointers * sec_obj_ptr;
+ void * private_cache_map;
+ int32_t final_status;
+ struct _nt_file_object * related_file_obj;
+ unsigned char lock_operation;
+ unsigned char delete_pending;
+ unsigned char read_access;
+ unsigned char write_access;
+ unsigned char delete_access;
+ unsigned char shared_read;
+ unsigned char shared_write;
+ unsigned char shared_delete;
+ uint32_t flags;
+ nt_unicode_string file_name;
+ nt_large_integer current_byte_offset;
+ uint32_t waiters;
+ uint32_t busy;
+ void * last_lock;
+ nt_kevent lock;
+ nt_kevent event;
+ nt_io_completion_context * completion_context;
+ uint32_t irp_list_lock;
+ nt_list_entry irp_list;
+ void * file_obj_ext;
+} nt_file_object;
+
+
+
+
+/* file-related function signatures */
+typedef int32_t __stdcall ntapi_zw_create_file(
+ __out void ** hfile,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __out nt_io_status_block * io_status_block,
+ __in nt_large_integer * allocation_size __optional,
+ __in uint32_t file_attr,
+ __in uint32_t share_access,
+ __in uint32_t create_disposition,
+ __in uint32_t create_options,
+ __in void * ea_buffer __optional,
+ __in uint32_t ea_length);
+
+
+typedef int32_t __stdcall ntapi_zw_open_file(
+ __out void ** hfile,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __out nt_io_status_block * io_status_block,
+ __in uint32_t share_access,
+ __in uint32_t open_options);
+
+
+typedef int32_t __stdcall ntapi_zw_delete_file(
+ __in nt_object_attributes * obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_flush_buffers_file(
+ __in void * hfile,
+ __out nt_io_status_block * io_status_block);
+
+
+typedef int32_t __stdcall ntapi_zw_cancel_io_file(
+ __in void * hfile,
+ __out nt_io_status_block * io_status_block);
+
+
+typedef int32_t __stdcall ntapi_zw_cancel_io_file_ex(
+ __in void * hfile,
+ __in nt_io_status_block * request_iosb __optional,
+ __out nt_io_status_block * cancel_iosb);
+
+
+typedef int32_t __stdcall ntapi_zw_read_file(
+ __in void * hfile,
+ __in void * hevent __optional,
+ __in nt_io_apc_routine * apc_routine __optional,
+ __in void * apc_context __optional,
+ __out nt_io_status_block * io_status_block,
+ __out void * buffer,
+ __in uint32_t bytes_to_read,
+ __in nt_large_integer * byte_offset __optional,
+ __in uint32_t * key __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_write_file(
+ __in void * hfile,
+ __in void * hevent __optional,
+ __in nt_io_apc_routine * apc_routine __optional,
+ __in void * apc_context __optional,
+ __out nt_io_status_block * io_status_block,
+ __in void * buffer,
+ __in uint32_t bytes_sent,
+ __in nt_large_integer * byte_offset __optional,
+ __in uint32_t * key __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_read_file_scatter(
+ __in void * hfile,
+ __in void * hevent __optional,
+ __in nt_io_apc_routine * apc_routine __optional,
+ __in void * apc_context __optional,
+ __out nt_io_status_block * io_status_block,
+ __in nt_file_segment_element * buffer,
+ __in uint32_t bytes_to_read,
+ __in nt_large_integer * byte_offset __optional,
+ __in uint32_t * key __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_write_file_gather(
+ __in void * hfile,
+ __in void * hevent __optional,
+ __in nt_io_apc_routine * apc_routine __optional,
+ __in void * apc_context __optional,
+ __out nt_io_status_block * io_status_block,
+ __in nt_file_segment_element * buffer,
+ __in uint32_t bytes_to_read,
+ __in nt_large_integer * byte_offset __optional,
+ __in uint32_t * key __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_lock_file(
+ __in void * hfile,
+ __in void * hevent __optional,
+ __in nt_io_apc_routine * apc_routine __optional,
+ __in void * apc_context __optional,
+ __out nt_io_status_block * io_status_block,
+ __in nt_large_integer * lock_offset,
+ __in nt_large_integer * lock_length,
+ __in uint32_t * key,
+ __in unsigned char fail_immediately,
+ __in unsigned char exclusive_lock);
+
+
+typedef int32_t __stdcall ntapi_zw_unlock_file(
+ __in void * hfile,
+ __out nt_io_status_block * io_status_block,
+ __in nt_large_integer * lock_offset,
+ __in nt_large_integer * lock_length,
+ __in uint32_t * key);
+
+
+typedef int32_t __stdcall ntapi_zw_device_io_control_file(
+ __in void * hfile,
+ __in void * hevent __optional,
+ __in nt_io_apc_routine * apc_routine __optional,
+ __in void * apc_context __optional,
+ __out nt_io_status_block * io_status_block,
+ __in uint32_t io_control_code,
+ __in void * input_buffer __optional,
+ __in uint32_t input_buffer_length,
+ __out void * output_buffer __optional,
+ __in uint32_t output_buffer_length);
+
+
+typedef int32_t __stdcall ntapi_zw_fs_control_file(
+ __in void * hfile,
+ __in void * hevent __optional,
+ __in nt_io_apc_routine * apc_routine __optional,
+ __in void * apc_context __optional,
+ __out nt_io_status_block * io_status_block,
+ __in uint32_t fs_control_code,
+ __in void * input_buffer __optional,
+ __in uint32_t input_buffer_length,
+ __out void * output_buffer __optional,
+ __in uint32_t output_buffer_length);
+
+
+typedef int32_t __stdcall ntapi_zw_notify_change_directory_file(
+ __in void * hfile ,
+ __in void * hevent __optional,
+ __in nt_io_apc_routine * apc_routine __optional,
+ __in void * apc_context __optional,
+ __out nt_io_status_block * io_status_block,
+ __out nt_file_notify_information * buffer,
+ __in uint32_t buffer_length,
+ __in uint32_t notify_filter,
+ __in unsigned char watch_subtree);
+
+
+typedef int32_t __stdcall ntapi_zw_query_ea_file(
+ __in void * hfile ,
+ __out nt_io_status_block * io_status_block,
+ __out nt_file_full_ea_information * buffer,
+ __in uint32_t buffer_length,
+ __in unsigned char return_single_entry,
+ __in nt_file_get_ea_information * ea_list __optional,
+ __in uint32_t ea_list_length,
+ __in uint32_t * ea_index __optional,
+ __in unsigned char restart_scan);
+
+
+typedef int32_t __stdcall ntapi_zw_set_ea_file(
+ __in void * hfile ,
+ __out nt_io_status_block * io_status_block,
+ __in nt_file_full_ea_information * buffer,
+ __in uint32_t buffer_length);
+
+
+typedef int32_t __stdcall ntapi_zw_create_named_pipe_file(
+ __out void ** hfile,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __out nt_io_status_block * io_status_block,
+ __in uint32_t share_access,
+ __in uint32_t create_disposition,
+ __in uint32_t create_options,
+ __in uint32_t type_message,
+ __in uint32_t readmode_message,
+ __in uint32_t non_blocking,
+ __in uint32_t max_instances,
+ __in size_t in_buffer_size,
+ __in size_t out_buffer_size,
+ __in nt_large_integer * default_timeout __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_create_mailslot_file(
+ __out void ** hfile,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __out nt_io_status_block * io_status_block,
+ __in uint32_t create_options,
+ __in uint32_t in_buffer_size,
+ __in uint32_t max_message_size,
+ __in nt_large_integer * read_timeout __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_query_volume_information_file(
+ __in void * hfile ,
+ __out nt_io_status_block * io_status_block,
+ __out void * vol_info,
+ __in uint32_t vol_info_length,
+ __in nt_fs_info_class vol_info_class);
+
+
+typedef int32_t __stdcall ntapi_zw_set_volume_information_file(
+ __in void * hfile ,
+ __out nt_io_status_block * io_status_block,
+ __in void * vol_info,
+ __in uint32_t vol_info_length,
+ __in nt_fs_info_class vol_info_class);
+
+
+typedef int32_t __stdcall ntapi_zw_query_quota_information_file(
+ __in void * hfile ,
+ __out nt_io_status_block * io_status_block,
+ __out nt_file_user_quota_information * buffer,
+ __in uint32_t buffer_length,
+ __in unsigned char returning_single_entry,
+ __in nt_file_quota_list_information * sid_list __optional,
+ __in uint32_t sid_list_length,
+ __in nt_sid * start_sid __optional,
+ __in unsigned char restart_scan);
+
+
+typedef int32_t __stdcall ntapi_zw_set_quota_information_file(
+ __in void * hfile ,
+ __out nt_io_status_block * io_status_block,
+ __in nt_file_user_quota_information * buffer,
+ __in uint32_t buffer_length);
+
+
+typedef int32_t __stdcall ntapi_zw_query_attributes_file(
+ __in nt_object_attributes * obj_attr,
+ __out nt_file_basic_information * file_info);
+
+
+typedef int32_t __stdcall ntapi_zw_query_full_attributes_file(
+ __in nt_object_attributes * obj_attr,
+ __out nt_file_network_open_information * file_info);
+
+
+typedef int32_t __stdcall ntapi_zw_query_directory_file(
+ __in void * hfile,
+ __in void * hevent __optional,
+ __in nt_io_apc_routine * apc_routine __optional,
+ __in void * apc_context __optional,
+ __out nt_io_status_block * io_status_block,
+ __out void * file_info,
+ __in uint32_t file_info_length,
+ __in nt_file_info_class file_info_class,
+ __in unsigned char return_single_entry,
+ __in nt_unicode_string * file_name __optional,
+ __in unsigned char restart_scan);
+
+
+typedef int32_t __stdcall ntapi_zw_query_information_file(
+ __in void * hfile,
+ __out nt_io_status_block * io_status_block,
+ __out void * file_info,
+ __in uint32_t file_info_length,
+ __in nt_file_info_class file_info_class);
+
+
+typedef int32_t __stdcall ntapi_zw_set_information_file(
+ __in void * hfile,
+ __out nt_io_status_block * io_status_block,
+ __in void * file_info,
+ __in uint32_t file_info_length,
+ __in nt_file_info_class file_info_class);
+
+/* extension functions */
+typedef int32_t __stdcall ntapi_tt_get_file_handle_type(
+ __in void * handle,
+ __out int32_t * type);
+
+typedef int32_t __stdcall ntapi_tt_open_logical_parent_directory(
+ __out void ** hparent,
+ __in void * hdir,
+ __out uintptr_t * buffer,
+ __in uint32_t buffer_size,
+ __in uint32_t desired_access,
+ __in uint32_t open_options,
+ __out int32_t * type);
+
+typedef int32_t __stdcall ntapi_tt_open_physical_parent_directory(
+ __out void ** hparent,
+ __in void * hdir,
+ __out uintptr_t * buffer,
+ __in uint32_t buffer_size,
+ __in uint32_t desired_access,
+ __in uint32_t open_options,
+ __out int32_t * type);
+
+#endif
diff --git a/include/ntapi/nt_fsctl.h b/include/ntapi/nt_fsctl.h
new file mode 100644
index 0000000..573946a
--- /dev/null
+++ b/include/ntapi/nt_fsctl.h
@@ -0,0 +1,44 @@
+#ifndef _NT_FSCTL_H_
+#define _NT_FSCTL_H_
+
+#define NT_FSCTL_CREATE_OR_GET_OBJECT_ID (0x000900c0)
+#define NT_FSCTL_DELETE_OBJECT_ID (0x000900a0)
+#define NT_FSCTL_DELETE_REPARSE_POINT (0x000900ac)
+#define NT_FSCTL_FILE_LEVEL_TRIM (0x00098208)
+#define NT_FSCTL_FILESYSTEM_GET_STATISTICS (0x00090060)
+#define NT_FSCTL_FIND_FILES_BY_SID (0x0009008f)
+#define NT_FSCTL_GET_COMPRESSION (0x0009003c)
+#define NT_FSCTL_GET_INTEGRITY_INFORMATION (0x0009027c)
+#define NT_FSCTL_GET_NTFS_VOLUME_DATA (0x00090064)
+#define NT_FSCTL_GET_REFS_VOLUME_DATA (0x000902D8)
+#define NT_FSCTL_GET_OBJECT_ID (0x0009009c)
+#define NT_FSCTL_GET_REPARSE_POINT (0x000900a8)
+#define NT_FSCTL_GET_RETRIEVAL_POINTERS (0x00090073)
+#define NT_FSCTL_IS_PATHNAME_VALID (0x0009002c)
+#define NT_FSCTL_LMR_SET_LINK_TRACKING_INFORMATION (0x001400ec)
+#define NT_FSCTL_OFFLOAD_READ (0x00094264)
+#define NT_FSCTL_OFFLOAD_WRITE (0x00098268)
+#define NT_FSCTL_PIPE_PEEK (0x0011400c)
+#define NT_FSCTL_PIPE_TRANSCEIVE (0x0011c017)
+#define NT_FSCTL_PIPE_WAIT (0x00110018)
+#define NT_FSCTL_QUERY_ALLOCATED_RANGES (0x000940cf)
+#define NT_FSCTL_QUERY_FAT_BPB (0x00090058)
+#define NT_FSCTL_QUERY_FILE_REGIONS (0x00090284)
+#define NT_FSCTL_QUERY_ON_DISK_VOLUME_INFO (0x0009013c)
+#define NT_FSCTL_QUERY_SPARING_INFO (0x00090138)
+#define NT_FSCTL_READ_FILE_USN_DATA (0x000900eb)
+#define NT_FSCTL_RECALL_FILE (0x00090117)
+#define NT_FSCTL_SET_COMPRESSION (0x0009c040)
+#define NT_FSCTL_SET_DEFECT_MANAGEMENT (0x00098134)
+#define NT_FSCTL_SET_ENCRYPTION (0x000900D7)
+#define NT_FSCTL_SET_INTEGRITY_INFORMATION (0x0009C280)
+#define NT_FSCTL_SET_OBJECT_ID (0x00090098)
+#define NT_FSCTL_SET_OBJECT_ID_EXTENDED (0x000900bc)
+#define NT_FSCTL_SET_REPARSE_POINT (0x000900a4)
+#define NT_FSCTL_SET_SPARSE (0x000900c4)
+#define NT_FSCTL_SET_ZERO_DATA (0x000980c8)
+#define NT_FSCTL_SET_ZERO_ON_DEALLOCATION (0x00090194)
+#define NT_FSCTL_SIS_COPYFILE (0x00090100)
+#define NT_FSCTL_WRITE_USN_CLOSE_RECORD (0x000900ef)
+
+#endif
diff --git a/include/ntapi/nt_guid.h b/include/ntapi/nt_guid.h
new file mode 100644
index 0000000..332a899
--- /dev/null
+++ b/include/ntapi/nt_guid.h
@@ -0,0 +1,37 @@
+#ifndef _NT_GUID_H_
+#define _NT_GUID_H_
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+
+typedef struct _nt_guid_str_utf16 {
+ wchar16_t lbrace;
+ wchar16_t group1[8];
+ wchar16_t dash1;
+ wchar16_t group2[4];
+ wchar16_t dash2;
+ wchar16_t group3[4];
+ wchar16_t dash3;
+ wchar16_t group4[4];
+ wchar16_t dash4;
+ wchar16_t group5[12];
+ wchar16_t rbrace;
+} nt_guid_str_utf16, nt_uuid_str_utf16;
+
+typedef void __fastcall ntapi_tt_guid_copy(
+ __out nt_guid * pguid_dst,
+ __in const nt_guid * pguid_src);
+
+typedef int32_t __fastcall ntapi_tt_guid_compare(
+ __in const nt_guid * pguid_dst,
+ __in const nt_guid * pguid_src);
+
+typedef void __fastcall ntapi_tt_guid_to_utf16_string(
+ __in const nt_guid * guid,
+ __out nt_guid_str_utf16 * guid_str);
+
+typedef int32_t __fastcall ntapi_tt_utf16_string_to_guid(
+ __in nt_guid_str_utf16 * guid_str,
+ __out nt_guid * guid);
+
+#endif
diff --git a/include/ntapi/nt_hash.h b/include/ntapi/nt_hash.h
new file mode 100644
index 0000000..f0e2492
--- /dev/null
+++ b/include/ntapi/nt_hash.h
@@ -0,0 +1,13 @@
+#ifndef _NT_HASH_H_
+#define _NT_HASH_H_
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_hash.h>
+
+typedef int32_t __cdecl ntapi_tt_populate_hashed_import_table(
+ __in void * image_base,
+ __in void * import_table,
+ __in ntapi_hashed_symbol * hash_table,
+ __in uint32_t hash_table_array_size);
+
+#endif
diff --git a/include/ntapi/nt_ioctl.h b/include/ntapi/nt_ioctl.h
new file mode 100644
index 0000000..994bc95
--- /dev/null
+++ b/include/ntapi/nt_ioctl.h
@@ -0,0 +1,31 @@
+#ifndef _NT_IOCTL_H_
+#define _NT_IOCTL_H_
+
+#define NT_IOCTL_MOUNTDEV_LINK_CREATED (0x004dc010)
+#define NT_IOCTL_MOUNTDEV_LINK_DELETED (0x004dc014)
+#define NT_IOCTL_MOUNTDEV_QUERY_DEVICE_NAME (0x004d0008)
+#define NT_IOCTL_MOUNTDEV_QUERY_STABLE_GUID (0x004d0018)
+#define NT_IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME (0x004d000c)
+#define NT_IOCTL_MOUNTDEV_QUERY_UNIQUE_ID (0x004d0000)
+
+#define NT_IOCTL_MOUNTMGR_AUTO_DL_ASSIGNMENTS (0x006dc014)
+#define NT_IOCTL_MOUNTMGR_BOOT_DL_ASSIGNMENT (0x006dc044)
+#define NT_IOCTL_MOUNTMGR_CHANGE_NOTIFY (0x006d4020)
+#define NT_IOCTL_MOUNTMGR_CHECK_UNPROCESSED_VOLUMES (0x006d4028)
+#define NT_IOCTL_MOUNTMGR_CREATE_POINT (0x006dc000)
+#define NT_IOCTL_MOUNTMGR_DELETE_POINTS (0x006dc004)
+#define NT_IOCTL_MOUNTMGR_DELETE_POINTS_DBONLY (0x006dc00c)
+#define NT_IOCTL_MOUNTMGR_KEEP_LINKS_WHEN_OFFLINE (0x006dc024)
+#define NT_IOCTL_MOUNTMGR_NEXT_DRIVE_LETTER (0x006dc010)
+#define NT_IOCTL_MOUNTMGR_QUERY_AUTO_MOUNT (0x006d003c)
+#define NT_IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH (0x006d0030)
+#define NT_IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATHS (0x006d0034)
+#define NT_IOCTL_MOUNTMGR_QUERY_POINTS (0x006d0008)
+#define NT_IOCTL_MOUNTMGR_SCRUB_REGISTRY (0x006dc038)
+#define NT_IOCTL_MOUNTMGR_SET_AUTO_MOUNT (0x006dc040)
+#define NT_IOCTL_MOUNTMGR_TRACELOG_CACHE (0x006d4048)
+#define NT_IOCTL_MOUNTMGR_VOLUME_ARRIVAL_NOTIFICATION (0x006d402c)
+#define NT_IOCTL_MOUNTMGR_VOLUME_MOUNT_POINT_CREATED (0x006dc018)
+#define NT_IOCTL_MOUNTMGR_VOLUME_MOUNT_POINT_DELETED (0x006dc01c)
+
+#endif
diff --git a/include/ntapi/nt_ipc.h b/include/ntapi/nt_ipc.h
new file mode 100644
index 0000000..6119b8b
--- /dev/null
+++ b/include/ntapi/nt_ipc.h
@@ -0,0 +1,12 @@
+#ifndef _NT_IPC_H_
+#define _NT_IPC_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+
+typedef int32_t __stdcall ntapi_ipc_create_pipe(
+ __out void ** hpipe_read,
+ __out void ** hpipe_write,
+ __in uint32_t advisory_buffer_size __optional);
+
+#endif
diff --git a/include/ntapi/nt_istat.h b/include/ntapi/nt_istat.h
new file mode 100644
index 0000000..5586628
--- /dev/null
+++ b/include/ntapi/nt_istat.h
@@ -0,0 +1,45 @@
+#ifndef _NT_ISTAT_H_
+#define _NT_ISTAT_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+#include "nt_file.h"
+
+/* ntapi_tt_istat info flag bits */
+#define NT_ISTAT_DEFAULT 0x00000000
+#define NT_ISTAT_COMMON 0x00000001
+#define NT_ISTAT_DEV_NAME_COPY 0x00000002
+#define NT_ISTAT_NEW_HANDLE 0x80000000
+
+typedef struct _nt_istat {
+ void * hfile;
+ nt_fii fii;
+ nt_ftagi ftagi;
+ uint32_t flags_in;
+ uint32_t flags_out;
+ uint32_t dev_name_hash;
+ uint16_t dev_name_strlen;
+ uint16_t dev_name_maxlen;
+ wchar16_t dev_name[];
+} nt_istat;
+
+
+typedef int32_t __stdcall ntapi_tt_istat(
+ __in void * hfile __optional,
+ __in void * hroot __optional,
+ __in nt_unicode_string * path __optional,
+ __out nt_istat * istat,
+ __out uintptr_t * buffer,
+ __in uint32_t buffer_size,
+ __in uint32_t open_options,
+ __in uint32_t flags);
+
+
+typedef int32_t __stdcall ntapi_tt_validate_fs_handle(
+ __in void * hfile,
+ __in uint32_t dev_name_hash,
+ __in nt_fii fii,
+ __out uintptr_t * buffer,
+ __in uint32_t buffer_size);
+
+#endif
diff --git a/include/ntapi/nt_job.h b/include/ntapi/nt_job.h
new file mode 100644
index 0000000..83a561e
--- /dev/null
+++ b/include/ntapi/nt_job.h
@@ -0,0 +1,212 @@
+#ifndef _NT_JOB_H_
+#define _NT_JOB_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+
+typedef enum _nt_job_object_info_class {
+ NT_JOB_OBJECT_BASIC_ACCOUNTING_INFORMATION = 0x01,
+ NT_JOB_OBJECT_BASIC_LIMIT_INFORMATION = 0x02,
+ NT_JOB_OBJECT_BASIC_PROCESS_ID_LIST = 0x03,
+ NT_JOB_OBJECT_BASIC_U_I_RESTRICTIONS = 0x04,
+ NT_JOB_OBJECT_SECURITY_LIMIT_INFORMATION = 0x05,
+ NT_JOB_OBJECT_END_OF_JOB_TIME_INFORMATION = 0x06,
+ NT_JOB_OBJECT_ASSOCIATE_COMPLETION_PORT_INFORMATION = 0x07,
+ NT_JOB_OBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION = 0x08,
+ NT_JOB_OBJECT_EXTENDED_LIMIT_INFORMATION = 0x09,
+
+ NT_JOB_OBJECT_GROUP_INFORMATION = 0x0B,
+ NT_JOB_OBJECT_NOTIFICATION_LIMIT_INFORMATION = 0x0C,
+ NT_JOB_OBJECT_LIMIT_VIOLATION_INFORMATION = 0x0D,
+ NT_JOB_OBJECT_GROUP_INFORMATION_EX = 0x0E,
+ NT_JOB_OBJECT_CPU_RATE_CONTROL_INFORMATION = 0x0F,
+} nt_job_object_info_class;
+
+/* job access bits */
+#define NT_JOB_OBJECT_ASSIGN_PROCESS 0x000001
+#define NT_JOB_OBJECT_SET_ATTRIBUTES 0x000002
+#define NT_JOB_OBJECT_QUERY 0x000004
+#define NT_JOB_OBJECT_TERMINATE 0x000008
+#define NT_JOB_OBJECT_SET_SECURITY_ATTRIBUTES 0x000010
+#define NT_JOB_OBJECT_ALL_ACCESS 0x1F001F
+
+/* job limit flags */
+#define NT_JOB_OBJECT_LIMIT_WORKINGSET 0x00000001
+#define NT_JOB_OBJECT_LIMIT_PROCESS_TIME 0x00000002
+#define NT_JOB_OBJECT_LIMIT_JOB_TIME 0x00000004
+#define NT_JOB_OBJECT_LIMIT_ACTIVE_PROCESS 0x00000008
+#define NT_JOB_OBJECT_LIMIT_AFFINITY 0x00000010
+#define NT_JOB_OBJECT_LIMIT_PRIORITY_CLASS 0x00000020
+#define NT_JOB_OBJECT_LIMIT_PRESERVE_JOB_TIME 0x00000040
+#define NT_JOB_OBJECT_LIMIT_SCHEDULING_CLASS 0x00000080
+#define NT_JOB_OBJECT_LIMIT_PROCESS_MEMORY 0x00000100
+#define NT_JOB_OBJECT_LIMIT_JOB_MEMORY 0x00000200
+#define NT_JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION 0x00000400
+#define NT_JOB_OBJECT_LIMIT_BREAKAWAY_OK 0x00000800
+#define NT_JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK 0x00001000
+#define NT_JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE 0x00002000
+#define NT_JOB_OBJECT_LIMIT_SUBSET_AFFINITY 0x00004000
+
+
+/* job object cpu rate control bits */
+#define NT_JOB_OBJECT_CPU_RATE_CONTROL_ENABLE 0x0001
+#define NT_JOB_OBJECT_CPU_RATE_CONTROL_WEIGHT_BASED 0x0002
+#define NT_JOB_OBJECT_CPU_RATE_CONTROL_HARD_CAP 0x0004
+#define NT_JOB_OBJECT_CPU_RATE_CONTROL_NOTIFY 0x0008
+
+
+/* job object basic user interface restrictions bits */
+#define NT_JOB_OBJECT_UILIMIT_HANDLES 0x00000001
+#define NT_JOB_OBJECT_UILIMIT_READCLIPBOARD 0x00000002
+#define NT_JOB_OBJECT_UILIMIT_WRITECLIPBOARD 0x00000004
+#define NT_JOB_OBJECT_UILIMIT_SYSTEMPARAMETERS 0x00000008
+#define NT_JOB_OBJECT_UILIMIT_DISPLAYSETTINGS 0x00000010
+#define NT_JOB_OBJECT_UILIMIT_GLOBALATOMS 0x00000020
+#define NT_JOB_OBJECT_UILIMIT_DESKTOP 0x00000040
+#define NT_JOB_OBJECT_UILIMIT_EXITWINDOWS 0x00000080
+
+
+/* job security limit bits */
+#define NT_JOB_OBJECT_SECURITY_NO_ADMIN 0x0001
+#define NT_JOB_OBJECT_SECURITY_RESTRICTED_TOKEN 0x0002
+#define NT_JOB_OBJECT_SECURITY_ONLY_TOKEN 0x0004
+#define NT_JOB_OBJECT_SECURITY_FILTER_TOKENS 0x0008
+
+
+/* end of job actions */
+#define NT_JOB_OBJECT_TERMINATE_AT_END_OF_JOB 0
+#define NT_JOB_OBJECT_POST_AT_END_OF_JOB 1
+
+
+/* job associate completion port events */
+#define NT_JOB_OBJECT_MSG_END_OF_JOB_TIME 1
+#define NT_JOB_OBJECT_MSG_END_OF_PROCESS_TIME 2
+#define NT_JOB_OBJECT_MSG_ACTIVE_PROCESS_LIMIT 3
+#define NT_JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO 4
+#define NT_JOB_OBJECT_MSG_NEW_PROCESS 6
+#define NT_JOB_OBJECT_MSG_EXIT_PROCESS 7
+#define NT_JOB_OBJECT_MSG_ABNORMAL_EXIT_PROCESS 8
+#define NT_JOB_OBJECT_MSG_PROCESS_MEMORY_LIMIT 9
+#define NT_JOB_OBJECT_MSG_JOB_MEMORY_LIMIT 10
+
+
+typedef struct _nt_job_object_basic_accounting_information {
+ nt_large_integer total_user_time;
+ nt_large_integer total_kernel_time;
+ nt_large_integer this_period_total_user_time;
+ nt_large_integer this_period_total_kernel_time;
+ int32_t total_page_fault_count;
+ int32_t total_processes;
+ int32_t active_processes;
+ int32_t total_terminated_processes;
+} nt_job_object_basic_accounting_information;
+
+
+typedef struct _nt_job_object_basic_limit_information {
+ nt_large_integer per_process_user_time_limit;
+ nt_large_integer per_job_user_time_limit;
+ uint32_t limit_flags;
+ size_t minimum_working_set_size;
+ size_t maximum_working_set_size;
+ uint32_t active_process_limit;
+ uintptr_t affinity;
+ uint32_t priority_class;
+ uint32_t scheduling_class;
+} nt_job_object_basic_limit_information;
+
+
+typedef struct _nt_job_object_basic_and_io_accounting_information {
+ nt_job_object_basic_accounting_information basic_info;
+ nt_io_counters io_info;
+} nt_job_object_basic_and_io_accounting_information;
+
+
+typedef struct _nt_job_object_extended_limit_information {
+ nt_job_object_basic_limit_information basic_limit_information;
+ nt_io_counters io_info;
+ size_t process_memory_limit;
+ size_t job_memory_limit;
+ size_t peak_process_memory_used;
+ size_t peak_job_memory_used;
+} nt_job_object_extended_limit_information;
+
+
+typedef struct _nt_job_object_basic_process_id_list {
+ uint32_t number_of_assigned_processes;
+ uint32_t number_of_process_ids_in_list;
+ uintptr_t process_id_list[];
+} nt_job_object_basic_process_id_list;
+
+
+typedef struct _nt_job_object_basic_ui_restrictions {
+ uint32_t ui_restrictions_class;
+} nt_job_object_basic_ui_restrictions;
+
+
+typedef struct _nt_job_object_security_limit_information {
+ uint32_t security_limit_flags;
+ void * job_token;
+ nt_token_groups * sids_to_disable;
+ nt_token_privileges * privileges_to_delete;
+ nt_token_groups * restricted_sids;
+} nt_job_object_security_limit_information;
+
+
+typedef struct _nt_job_object_end_of_job_time_information {
+ uint32_t end_of_job_time_action;
+} nt_job_object_end_of_job_time_information;
+
+
+typedef struct _nt_job_object_associate_completion_port {
+ void * completion_key;
+ void * completion_port;
+} nt_job_object_associate_completion_port;
+
+
+typedef struct _nt_job_object_cpu_rate_control_information {
+ uint32_t control_flags;
+ union {
+ uint32_t cpu_rate;
+ uint32_t weight;
+ };
+} nt_job_object_cpu_rate_control_information;
+
+
+
+typedef int32_t __stdcall ntapi_zw_create_job_object(
+ __out void ** hjob,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_open_job_object(
+ __out void ** hjob,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_terminate_job_object(
+ __in void * hjob,
+ __in int32_t exit_status);
+
+
+typedef int32_t __stdcall ntapi_zw_assign_process_to_job_object(
+ __in void * hjob,
+ __in void * hprocess);
+
+
+typedef int32_t __stdcall ntapi_zw_query_information_job_object(
+ __in void * hjob,
+ __in nt_job_object_info_class job_info_class,
+ __out void * job_info,
+ __in size_t job_info_length,
+ __out size_t * returned_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_set_information_job_object(
+ __in void * hjob,
+ __in nt_job_object_info_class job_info_class,
+ __in void * job_info,
+ __in size_t job_info_length);
+
+#endif
diff --git a/include/ntapi/nt_ldr.h b/include/ntapi/nt_ldr.h
new file mode 100644
index 0000000..09ab179
--- /dev/null
+++ b/include/ntapi/nt_ldr.h
@@ -0,0 +1,33 @@
+#ifndef _NT_LDR_H_
+#define _NT_LDR_H_
+
+#include <psxtypes/psxtypes.h>
+#include <dalist/dalist.h>
+#include <ntapi/nt_object.h>
+
+typedef int32_t __stdcall ntapi_ldr_load_dll(
+ __in wchar16_t * image_path __optional,
+ __in uint32_t * image_flags __optional,
+ __in nt_unicode_string * image_name,
+ __out void ** image_base);
+
+
+typedef int32_t __stdcall ntapi_ldr_unload_dll(
+ __in void * image_base);
+
+
+/* extensions */
+typedef int32_t __stdcall ntapi_ldr_load_system_dll(
+ __in void * hsysdir __optional,
+ __in wchar16_t * base_name,
+ __in uint32_t base_name_size,
+ __in uint32_t * image_flags __optional,
+ __out void ** image_base);
+
+typedef int __cdecl ntapi_ldr_create_state_snapshot(
+ __out struct dalist_ex * ldr_state_snapshot);
+
+typedef int __cdecl ntapi_ldr_revert_state_to_snapshot(
+ __in struct dalist_ex * ldr_state_snapshot);
+
+#endif
diff --git a/include/ntapi/nt_locale.h b/include/ntapi/nt_locale.h
new file mode 100644
index 0000000..7d7ef80
--- /dev/null
+++ b/include/ntapi/nt_locale.h
@@ -0,0 +1,31 @@
+#ifndef _NT_LOCALE_H_
+#define _NT_LOCALE_H_
+
+#include <psxtypes/psxtypes.h>
+
+typedef uint32_t nt_lcid;
+typedef uint16_t nt_langid;
+
+
+typedef int32_t __stdcall ntapi_zw_query_default_locale(
+ __in unsigned char thread_or_system,
+ __out nt_lcid * locale);
+
+
+typedef int32_t __stdcall ntapi_zw_set_default_locale(
+ __in unsigned char thread_or_system,
+ __in nt_lcid * locale);
+
+
+typedef int32_t __stdcall ntapi_zw_query_default_ui_language(
+ __out nt_langid * lang_id);
+
+
+typedef int32_t __stdcall ntapi_zw_set_default_ui_language(
+ __in nt_langid * lang_id);
+
+
+typedef int32_t __stdcall ntapi_zw_query_install_ui_language(
+ __out nt_langid * lang_id);
+
+#endif
diff --git a/include/ntapi/nt_memory.h b/include/ntapi/nt_memory.h
new file mode 100644
index 0000000..72bc452
--- /dev/null
+++ b/include/ntapi/nt_memory.h
@@ -0,0 +1,199 @@
+#ifndef _NT_MEMORY_H_
+#define _NT_MEMORY_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+
+typedef enum _nt_memory_info_class {
+ NT_MEMORY_BASIC_INFORMATION,
+ NT_MEMORY_WORKING_SET_LIST,
+ NT_MEMORY_SECTION_NAME,
+ NT_MEMORY_BASIC_VLM_INFORMATION
+} nt_memory_info_class;
+
+/* memory allocation granularity: same on all supported systems */
+#define NT_ALLOCATION_GRANULARITY (0x10000)
+
+/* memory (de)allocation types */
+#define NT_MEM_PAGE_GUARD 0x00000100 /* protect */
+#define NT_MEM_COMMIT 0x00001000 /* commit */
+#define NT_MEM_RESERVE 0x00002000 /* reserve only */
+#define NT_MEM_DECOMMIT 0x00004000 /* decommit but maintain reservavion */
+#define NT_MEM_RELEASE 0x00008000 /* decommit and cancel reservation */
+#define NT_MEM_RESET 0x00080000 /* make obsolete */
+#define NT_MEM_TOP_DOWN 0x00100000 /* allocate at highest possible address using a slow and possibly buggy algorithm */
+#define NT_MEM_WRITE_WATCH 0x00200000 /* track writes */
+#define NT_MEM_PHYSICAL 0x00400000 /* physical view */
+#define NT_MEM_RESET_UNDO AVOID 0x01000000 /* only after a successful NT_MEM_RESET */
+#define NT_MEM_LARGE_PAGES 0x20000000 /* use large-page support */
+#define NT_MEM_FREE 0x00010000 /* informational only: nt_memory_basic_information.state */
+#define NT_MEM_IMAGE 0x01000000 /* informational only: nt_memory_basic_information.type */
+#define NT_MEM_MAPPED 0x00040000 /* informational only: nt_memory_basic_information.type */
+#define NT_MEM_PRIVATE 0x00020000 /* informational only: nt_memory_basic_information.type */
+
+
+/* memory page access bits */
+#define NT_PAGE_NOACCESS (uint32_t)0x01
+#define NT_PAGE_READONLY (uint32_t)0x02
+#define NT_PAGE_READWRITE (uint32_t)0x04
+#define NT_PAGE_WRITECOPY (uint32_t)0x08
+#define NT_PAGE_EXECUTE (uint32_t)0x10
+#define NT_PAGE_EXECUTE_READ (uint32_t)0x20
+#define NT_PAGE_EXECUTE_READWRITE (uint32_t)0x40
+#define NT_PAGE_EXECUTE_WRITECOPY (uint32_t)0x80
+
+
+/* working set list entries: basic attributes */
+#define NT_WSLE_PAGE_NOT_ACCESSED 0x0000
+#define NT_WSLE_PAGE_READONLY 0x0001
+#define NT_WSLE_PAGE_EXECUTE 0x0002
+#define NT_WSLE_PAGE_EXECUTE_READ 0x0003
+#define NT_WSLE_PAGE_READWRITE 0x0004
+#define NT_WSLE_PAGE_WRITECOPY 0x0005
+#define NT_WSLE_PAGE_EXECUTE_READWRITE 0x0006
+#define NT_WSLE_PAGE_EXECUTE_WRITECOPY 0x0007
+
+/* working set list entries: extended attributes */
+#define NT_WSLE_PAGE_NO_CACHE 0x0008
+#define NT_WSLE_PAGE_GUARD_PAGE 0x0010
+#define NT_WSLE_PAGE_SHARE_COUNT_MASK 0x00E0
+#define NT_WSLE_PAGE_SHAREABLE 0x0100
+
+/* ntapi_zw_lock_virtual_memory lock types */
+#define NT_LOCK_VM_IN_WSL 0x0001
+#define NT_LOCK_VM_IN_RAM 0x0002
+
+
+typedef struct _nt_memory_basic_information {
+ void * base_address;
+ void * allocation_base;
+ uint32_t allocation_protect;
+ size_t region_size;
+ uint32_t state;
+ uint32_t protect;
+ uint32_t type;
+} nt_memory_basic_information;
+
+
+typedef struct _nt_memory_working_set_list {
+ uintptr_t number_of_pages;
+ uintptr_t nt_working_set_list_entry[];
+} nt_memory_working_set_list;
+
+
+typedef struct _nt_memory_section_name {
+ nt_unicode_string section_name;
+ wchar16_t section_name_buffer[];
+} nt_memory_section_name, nt_mem_sec_name;
+
+
+typedef int32_t __stdcall ntapi_zw_allocate_virtual_memory(
+ __in void * hprocess,
+ __in_out void ** base_address,
+ __in uint32_t zero_bits,
+ __in_out size_t * allocation_size,
+ __in uint32_t allocation_type,
+ __in uint32_t protect);
+
+
+typedef int32_t __stdcall ntapi_zw_free_virtual_memory(
+ __in void * hprocess,
+ __in_out void ** base_address,
+ __in_out size_t * free_size,
+ __in uint32_t deallocation_type);
+
+
+typedef int32_t __stdcall ntapi_zw_query_virtual_memory(
+ __in void * hprocess,
+ __in void * base_address,
+ __in nt_memory_info_class mem_info_class,
+ __out void * mem_info,
+ __in size_t mem_info_length,
+ __out size_t * returned_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_protect_virtual_memory(
+ __in void * hprocess,
+ __in void ** base_address,
+ __in size_t * protect_size,
+ __in uint32_t protect_type_new,
+ __out uint32_t * protect_type_old);
+
+
+typedef int32_t __stdcall ntapi_zw_read_virtual_memory(
+ __in void * hprocess,
+ __in void * base_address,
+ __out char * buffer,
+ __in size_t buffer_length,
+ __out size_t * bytes_written);
+
+
+typedef int32_t __stdcall ntapi_zw_write_virtual_memory(
+ __in void * hprocess,
+ __in void * base_address,
+ __in char * buffer,
+ __in size_t buffer_length,
+ __out size_t * bytes_written);
+
+
+typedef int32_t __stdcall ntapi_zw_lock_virtual_memory(
+ __in void * hprocess,
+ __in_out void ** base_address,
+ __in_out size_t * lock_size,
+ __in uint32_t lock_type);
+
+
+typedef int32_t __stdcall ntapi_zw_unlock_virtual_memory(
+ __in void * hprocess,
+ __in_out void ** base_address,
+ __in_out size_t * lock_size,
+ __in uint32_t lock_type);
+
+
+typedef int32_t __stdcall ntapi_zw_flush_virtual_memory(
+ __in void * hprocess,
+ __in_out void ** base_address,
+ __in_out size_t * flush_size,
+ __in nt_io_status_block * flush_type);
+
+
+typedef int32_t __stdcall ntapi_zw_allocate_user_physical_pages(
+ __in void * hprocess,
+ __in_out uintptr_t * number_of_pages,
+ __out uintptr_t * arr_page_frame_numbers);
+
+
+typedef int32_t __stdcall ntapi_zw_free_user_physical_pages(
+ __in void * hprocess,
+ __in_out uintptr_t * number_of_pages,
+ __in uintptr_t * arr_page_frame_numbers);
+
+
+typedef int32_t __stdcall ntapi_zw_map_user_physical_pages(
+ __in void * base_address,
+ __in_out uintptr_t * number_of_pages,
+ __in uintptr_t * arr_page_frame_numbers);
+
+
+typedef int32_t __stdcall ntapi_zw_map_user_physical_pages_scatter(
+ __in void ** virtual_addresses,
+ __in_out uintptr_t * number_of_pages,
+ __in uintptr_t * arr_page_options);
+
+
+typedef uint32_t __stdcall ntapi_zw_get_write_watch(
+ __in void * hprocess,
+ __in uint32_t flags,
+ __in void * base_address,
+ __in size_t region_size,
+ __out uintptr_t * buffer,
+ __in_out uintptr_t * buffer_entries,
+ __out uintptr_t * granularity);
+
+
+typedef uint32_t __stdcall ntapi_zw_reset_write_watch(
+ __in void * hprocess,
+ __in void * base_address,
+ __in size_t region_size);
+
+#endif
diff --git a/include/ntapi/nt_mount.h b/include/ntapi/nt_mount.h
new file mode 100644
index 0000000..8a7258a
--- /dev/null
+++ b/include/ntapi/nt_mount.h
@@ -0,0 +1,135 @@
+#ifndef _NT_MOUNT_H_
+#define _NT_MOUNT_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_ioctl.h"
+#include "nt_statfs.h"
+
+/* hash mark */
+/* {'\\','D','e','v','i','c','e','\\'} */
+#define __DEVICE_PATH_PREFIX_LEN (8 * sizeof(wchar16_t))
+#define __DEVICE_PATH_PREFIX_HASH (0xDA6FA40B)
+
+/* {'\\','?','?','\\','V','o','l','u','m','e','{'} */
+#define __VOLUME_PATH_PREFIX_LEN (11 * sizeof(wchar16_t))
+#define __VOLUME_PATH_PREFIX_HASH (0xFEBA8529)
+
+/* {'\\','D','o','s','D','e','v','i','c','e','s'} */
+#define __DOS_DEVICES_PREFIX_LEN (11 * sizeof(wchar16_t))
+#define __DOS_DEVICES_PREFIX_HASH (0x565D0514)
+
+
+typedef enum _nt_mount_moint_type {
+ NT_MOUNT_POINT_NONE,
+ NT_MOUNT_POINT_DEVICE,
+ NT_MOUNT_POINT_VOLUME,
+ NT_MOUNT_POINT_DIRECTORY
+} nt_mount_moint_type;
+
+/* reparse tag values */
+#define NT_IO_REPARSE_TAG_RESERVED_ZERO (0x00000000)
+#define NT_IO_REPARSE_TAG_RESERVED_ONE (0x00000001)
+#define NT_IO_REPARSE_TAG_MOUNT_POINT (0xA0000003)
+#define NT_IO_REPARSE_TAG_HSM (0xC0000004)
+#define NT_IO_REPARSE_TAG_HSM2 (0x80000006)
+#define NT_IO_REPARSE_TAG_DRIVER_EXTENDER (0x80000005)
+#define NT_IO_REPARSE_TAG_SIS (0x80000007)
+#define NT_IO_REPARSE_TAG_DFS (0x8000000A)
+#define NT_IO_REPARSE_TAG_DFSR (0x80000012)
+#define NT_IO_REPARSE_TAG_FILTER_MANAGER (0x8000000B)
+#define NT_IO_REPARSE_TAG_SYMLINK (0xA000000C)
+
+
+typedef struct _nt_mount_dev_name {
+ uint16_t name_length;
+ wchar16_t name[];
+} nt_mount_dev_name;
+
+
+typedef struct _nt_mount_mgr_mount_point {
+ uint32_t symlink_name_offset;
+ uint16_t symlink_name_length;
+ uint32_t unique_id_offset;
+ uint16_t unique_id_length;
+ uint32_t device_name_offset;
+ uint16_t device_name_length;
+} nt_mount_mgr_mount_point, nt_mount_point;
+
+
+typedef struct _nt_mount_mgr_mount_point_param {
+ uint32_t symlink_name_offset;
+ uint16_t symlink_name_length;
+ uint32_t unique_id_offset;
+ uint16_t unique_id_length;
+ uint32_t device_name_offset;
+ uint16_t device_name_length;
+ uint16_t mount_points_offset;
+ wchar16_t device_name[];
+} nt_mount_mgr_mount_point_param, nt_mount_point_param;
+
+
+typedef struct _nt_mount_mgr_mount_points {
+ uint32_t size;
+ uint32_t number;
+ nt_mount_mgr_mount_point mount_points[];
+} nt_mount_mgr_mount_points, nt_mount_points;
+
+
+typedef struct _nt_mount_point_reparse_buffer {
+ uint32_t reparse_tag;
+ uint16_t reparse_data_length;
+ uint16_t reserved;
+ uint16_t substitute_name_offset;
+ uint16_t substitute_name_length;
+ uint16_t print_name_offset;
+ uint16_t print_name_length;
+ uintptr_t path_buffer[];
+} _nt_mount_point_reparse_buffer, nt_mprb;
+
+
+typedef struct _nt_dos_devices_name {
+ wchar16_t dos_devices_prefix[11];
+ wchar16_t slash;
+ wchar16_t letter;
+ wchar16_t colon;
+} nt_dos_devices_name;
+
+
+typedef int32_t __stdcall ntapi_tt_get_dos_drive_device_handle(
+ __out void ** hdevice,
+ __in wchar16_t * drive_letter);
+
+
+typedef int32_t __stdcall ntapi_tt_get_dos_drive_root_handle(
+ __out void ** hroot,
+ __in wchar16_t * drive_letter);
+
+
+typedef int32_t __stdcall ntapi_tt_get_dos_drive_device_name(
+ __in void * hdevice __optional,
+ __in wchar16_t * drive_letter __optional,
+ __out nt_mount_dev_name * buffer,
+ __in uint32_t buffer_size);
+
+
+typedef int32_t __stdcall ntapi_tt_get_dos_drive_mount_points(
+ __in void * hdevice __optional,
+ __in wchar16_t * drive_letter __optional,
+ __in nt_mount_dev_name * dev_name __optional,
+ __out void * buffer,
+ __in uint32_t buffer_size);
+
+
+typedef int32_t __stdcall ntapi_tt_dev_mount_points_to_statfs(
+ __in nt_mount_points * mount_points,
+ __in_out nt_statfs * statfs);
+
+
+typedef int32_t __stdcall ntapi_tt_get_dos_drive_letter_from_device(
+ __in void * hdevice __optional,
+ __out wchar16_t * drive_letter,
+ __in nt_mount_dev_name * dev_name __optional,
+ __out void * buffer,
+ __in uint32_t buffer_size);
+
+#endif
diff --git a/include/ntapi/nt_object.h b/include/ntapi/nt_object.h
new file mode 100644
index 0000000..bc4df6f
--- /dev/null
+++ b/include/ntapi/nt_object.h
@@ -0,0 +1,514 @@
+#ifndef _NT_OBJECT_H_
+#define _NT_OBJECT_H_
+
+#include <psxtypes/psxtypes.h>
+
+typedef enum _nt_object_info_class {
+ NT_OBJECT_BASIC_INFORMATION = 0,
+ NT_OBJECT_NAME_INFORMATION = 1,
+ NT_OBJECT_TYPE_INFORMATION = 2,
+ NT_OBJECT_ALL_TYPES_INFORMATION = 3,
+ NT_OBJECT_HANDLE_INFORMATION = 4
+} nt_object_info_class;
+
+
+typedef enum _nt_security_impersonation_level {
+ NT_SECURITY_ANONYMOUS = 0,
+ NT_SECURITY_IDENTIFICATION = 1,
+ NT_SECURITY_IMPERSONATION = 2,
+ NT_SECURITY_DELEGATION = 3
+} nt_security_impersonation_level;
+
+
+typedef enum _nt_security_information {
+ NT_OWNER_SECURITY_INFORMATION = 0x01,
+ NT_GROUP_SECURITY_INFORMATION = 0x02,
+ NT_DACL_SECURITY_INFORMATION = 0x04,
+ NT_SACL_SECURITY_INFORMATION = 0x08
+} nt_security_information;
+
+
+
+/* generic access rights */
+#define NT_SEC_DELETE (0x00010000u)
+#define NT_SEC_READ_CONTROL (0x00020000u)
+#define NT_SEC_WRITE_DAC (0x00040000u)
+#define NT_SEC_WRITE_OWNER (0x00080000u)
+#define NT_SEC_SYNCHRONIZE (0x00100000u)
+#define NT_SEC_STANDARD_RIGHTS_REQUIRED (0x000F0000u)
+#define NT_SEC_STANDARD_RIGHTS_READ NT_SEC_READ_CONTROL
+#define NT_SEC_STANDARD_RIGHTS_WRITE NT_SEC_READ_CONTROL
+#define NT_SEC_STANDARD_RIGHTS_EXECUTE NT_SEC_READ_CONTROL
+#define NT_SEC_STANDARD_RIGHTS_ALL (0x001F0000u)
+#define NT_SEC_SPECIFIC_RIGHTS_ALL (0x0000FFFFu)
+
+#define NT_GENERIC_ALL (0x10000000u)
+#define NT_GENERIC_EXECUTE (0x20000000u)
+#define NT_GENERIC_WRITE (0x40000000u)
+#define NT_GENERIC_READ (0x80000000u)
+
+
+/* zw_open_directory access rights */
+#define NT_DIRECTORY_QUERY (0x0001u)
+#define NT_DIRECTORY_TRAVERSE (0x0002u)
+#define NT_DIRECTORY_CREATE_OBJECT (0x0004u)
+#define NT_DIRECTORY_CREATE_SUBDIRECTORY (0x0008u)
+#define NT_DIRECTORY_ALL_ACCESS NT_DIRECTORY_QUERY \
+ | NT_DIRECTORY_TRAVERSE \
+ | NT_DIRECTORY_CREATE_OBJECT \
+ | NT_DIRECTORY_CREATE_SUBDIRECTORY \
+ | NT_SEC_STANDARD_RIGHTS_REQUIRED
+
+/* zw_open_symbolic_link_object access rights */
+#define NT_SYMBOLIC_LINK_QUERY (0x0001u)
+#define NT_SYMBOLIC_LINK_ALL_ACCESS NT_SYMBOLIC_LINK_QUERY \
+ | NT_SEC_STANDARD_RIGHTS_REQUIRED
+
+/* object handles */
+#define NT_HANDLE_FLAG_INHERIT (0x0001u)
+#define NT_HANDLE_FLAG_PROTECT_FROM_CLOSE (0x0002u)
+#define NT_HANDLE_PERMANENT (0x0010u)
+#define NT_HANDLE_EXCLUSIVE (0x0020u)
+#define NT_INVALID_HANDLE_VALUE ((void *)(intptr_t)-1)
+
+/* object attribute bits */
+#define NT_OBJ_INHERIT (0x0002u)
+#define NT_OBJ_PERMANENT (0x0010u)
+#define NT_OBJ_EXCLUSIVE (0x0020u)
+#define NT_OBJ_CASE_INSENSITIVE (0x0040u)
+#define NT_OBJ_OPENIF (0x0080u)
+#define NT_OBJ_OPENLINK (0x0100u)
+#define NT_OBJ_KERNEL_HANDLE (0x0200u)
+
+/* duplicate object bits */
+#define NT_DUPLICATE_CLOSE_SOURCE (0x0001u)
+#define NT_DUPLICATE_SAME_ACCESS (0x0002u)
+#define NT_DUPLICATE_SAME_ATTRIBUTES (0x0004u)
+
+/* nt_security_descriptor constants (IFS open specification) */
+#define NT_SE_OWNER_DEFAULTED (int16_t)0x0001
+#define NT_SE_GROUP_DEFAULTED (int16_t)0x0002
+#define NT_SE_DACL_PRESENT (int16_t)0x0004
+#define NT_SE_DACL_DEFAULTED (int16_t)0x0008
+#define NT_SE_SACL_PRESENT (int16_t)0x0010
+#define NT_SE_SACL_DEFAULTED (int16_t)0x0020
+#define NT_SE_DACL_AUTO_INHERIT_REQ (int16_t)0x0100
+#define NT_SE_SACL_AUTO_INHERIT_REQ (int16_t)0x0200
+#define NT_SE_DACL_AUTO_INHERITED (int16_t)0x0400
+#define NT_SE_SACL_AUTO_INHERITED (int16_t)0x0800
+#define NT_SE_DACL_PROTECTED (int16_t)0x1000
+#define NT_SE_SACL_PROTECTED (int16_t)0x2000
+#define NT_SE_RM_CONTROL_VALID (int16_t)0x4000
+#define NT_SE_SELF_RELATIVE (int16_t)0x8000
+
+/* security tracking */
+#define NT_SECURITY_TRACKING_STATIC 0
+#define NT_SECURITY_TRACKING_DYNAMIC 1
+
+/* predefined security authorities */
+#define NT_SECURITY_NULL_SID_AUTHORITY 0
+#define NT_SECURITY_WORLD_SID_AUTHORITY 1
+#define NT_SECURITY_LOCAL_SID_AUTHORITY 2
+#define NT_SECURITY_CREATOR_SID_AUTHORITY 3
+#define NT_SECURITY_NON_UNIQUE_AUTHORITY 4
+#define NT_SECURITY_NT_AUTHORITY 5
+
+/* token source length */
+#define NT_TOKEN_SOURCE_LENGTH 8
+
+
+typedef struct _nt_unicode_string {
+ uint16_t strlen;
+ uint16_t maxlen;
+ uint16_t * buffer;
+} nt_unicode_string;
+
+
+typedef union _nt_large_integer {
+ struct {
+ uint32_t ulow;
+ int32_t ihigh;
+ };
+ long long quad;
+} nt_large_integer, nt_timeout, nt_filetime, nt_sec_size;
+
+
+typedef struct _nt_io_status_block {
+ union {
+ int32_t status;
+ void * pointer;
+ };
+ intptr_t info;
+} nt_io_status_block, nt_iosb;
+
+
+typedef struct _nt_quota_limits {
+ size_t paged_pool_limit;
+ size_t non_paged_pool_limit;
+ size_t minimum_working_set_size;
+ size_t maximum_working_set_size;
+ size_t pagefile_limit;
+ nt_large_integer time_limit;
+} nt_quota_limits, nt_ql;
+
+
+typedef struct _nt_kernel_user_times {
+ nt_large_integer create_time;
+ nt_large_integer exit_time;
+ nt_large_integer kernel_time;
+ nt_large_integer user_time;
+} nt_kernel_user_times, nt_kut;
+
+
+typedef struct _nt_io_counters {
+ nt_large_integer read_operation_count;
+ nt_large_integer write_operation_count;
+ nt_large_integer other_operation_count;
+ nt_large_integer read_transfer_count;
+ nt_large_integer write_transfer_count;
+ nt_large_integer other_transfer_count;
+} nt_io_counters;
+
+
+typedef struct _nt_vm_counters {
+ size_t peak_virtual_size;
+ size_t virtual_size;
+ size_t page_fault_count;
+ size_t peak_working_set_size;
+ size_t working_set_size;
+ size_t quota_peak_paged_pool_usage;
+ size_t quota_paged_pool_usage;
+ size_t quota_peak_non_paged_pool_usage;
+ size_t quota_non_paged_pool_usage;
+ size_t pagefile_usage;
+ size_t peak_pagefile_usage;
+} nt_vm_counters;
+
+
+typedef struct _nt_pooled_usage_and_limits {
+ size_t peak_paged_pool_usage;
+ size_t paged_pool_usage;
+ size_t paged_pool_limit;
+ size_t peak_non_paged_pool_usage;
+ size_t non_paged_pool_usage;
+ size_t non_paged_pool_limit;
+ size_t peak_pagefile_usage;
+ size_t pagefile_usage;
+ size_t pagefile_limit;
+} nt_pooled_usage_and_limits, nt_pual;
+
+
+typedef struct _nt_client_id {
+ uintptr_t process_id;
+ uintptr_t thread_id;
+} nt_client_id, nt_cid;
+
+
+typedef struct _nt_generic_mapping {
+ uint32_t generic_read;
+ uint32_t generic_write;
+ uint32_t generic_execute;
+ uint32_t generic_all;
+} nt_generic_mapping, nt_gmap;
+
+
+typedef struct _nt_security_attributes {
+ uint32_t length;
+ void * security_descriptor;
+ int32_t inherit_handle;
+} nt_security_attributes, nt_sa;
+
+
+typedef struct _nt_guid {
+ uint32_t data1;
+ uint16_t data2;
+ uint16_t data3;
+ unsigned char data4[8];
+} nt_guid, nt_uuid;
+
+
+typedef struct _nt_uuid_vector {
+ uint32_t count;
+ nt_uuid * uuid[];
+} nt_uuid_vector;
+
+
+typedef struct _nt_acl {
+ unsigned char acl_revision;
+ unsigned char sbz_1st;
+ uint16_t acl_size;
+ uint16_t ace_count;
+ uint16_t sbz_2nd;
+} nt_acl;
+
+
+typedef struct _nt_security_descriptor {
+ unsigned char revision;
+ unsigned char sbz_1st;
+ uint16_t control;
+ uint32_t offset_owner;
+ uint32_t offset_group;
+ uint32_t offset_sacl;
+ uint32_t offset_dacl;
+} nt_security_descriptor, nt_sd;
+
+
+typedef struct _nt_security_quality_of_service {
+ uint32_t length;
+ int32_t impersonation_level;
+ int32_t context_tracking_mode;
+ int32_t effective_only;
+} nt_security_quality_of_service, nt_sqos;
+
+
+typedef struct _nt_sid_identifier_authority {
+ unsigned char value[6];
+} nt_sid_identifier_authority;
+
+
+typedef struct _nt_sid {
+ unsigned char revision;
+ unsigned char sub_authority_count;
+ nt_sid_identifier_authority identifier_authority;
+ uint32_t sub_authority[1];
+} nt_sid;
+
+
+typedef struct _nt_sid_and_attributes {
+ nt_sid * sid;
+ uint32_t attributes;
+} nt_sid_and_attributes;
+
+
+typedef struct _nt_token_user {
+ nt_sid_and_attributes user;
+} nt_token_user;
+
+
+typedef struct _nt_token_owner {
+ nt_sid * owner;
+} nt_token_owner;
+
+
+typedef struct _nt_token_primary_group {
+ nt_sid * primary_group;
+} nt_token_primary_group;
+
+
+typedef struct _nt_token_groups {
+ uint32_t group_count;
+ nt_sid_and_attributes groups[];
+} nt_token_groups;
+
+
+typedef struct _nt_token_default_dacl {
+ nt_acl * default_dacl;
+} nt_token_default_dacl;
+
+
+typedef struct _nt_luid {
+ uint32_t low;
+ int32_t high;
+} nt_luid;
+
+
+typedef struct _nt_token_origin {
+ nt_luid originating_logon_session;
+} nt_token_origin;
+
+
+typedef struct _nt_token_source {
+ char source_name[NT_TOKEN_SOURCE_LENGTH];
+ nt_luid source_identifier;
+} nt_token_source;
+
+
+typedef struct _nt_luid_and_attributes {
+ nt_luid luid;
+ uint32_t attributes;
+} nt_luid_and_attributes;
+
+
+typedef struct _nt_token_privileges {
+ uint32_t privilege_count;
+ nt_luid_and_attributes privileges[];
+} nt_token_privileges;
+
+
+typedef struct _nt_object_attributes {
+ uint32_t len;
+ void * root_dir;
+ nt_unicode_string * obj_name;
+ uint32_t obj_attr;
+ nt_security_descriptor *sec_desc;
+ nt_sqos * sec_qos;
+} nt_object_attributes, nt_oa;
+
+
+typedef struct _nt_object_basic_information {
+ uint32_t attributes;
+ uint32_t granted_access;
+ uint32_t handle_count;
+ uint32_t pointer_count;
+ uint32_t paged_pool_usage;
+ uint32_t non_paged_pool_usage;
+ uint32_t reserved[3];
+ uint32_t name_information_length;
+ uint32_t type_information_length;
+ uint32_t security_descriptor_length;
+ nt_large_integer create_time;
+} nt_object_basic_information;
+
+
+typedef struct _nt_object_name_information {
+ nt_unicode_string name;
+} nt_object_name_information;
+
+
+
+typedef struct _nt_object_handle_information {
+ unsigned char inherit;
+ unsigned char protect_from_close;
+} nt_object_handle_information, nt_ohio;
+
+
+typedef struct _nt_directory_basic_information {
+ nt_unicode_string object_name;
+ nt_unicode_string object_type_name;
+} nt_directory_basic_information;
+
+
+typedef struct _nt_keyed_object_directory_guid {
+ wchar16_t uscore_guid;
+ wchar16_t pgrp_guid[36];
+ wchar16_t uscore_key;
+} nt_keyed_object_directory_guid, nt_keyed_objdir_guid;
+
+typedef struct _nt_keyed_object_directory_name {
+ wchar16_t base_named_objects[17];
+ wchar16_t backslash;
+ wchar16_t prefix[6];
+ nt_keyed_objdir_guid objdir_guid;
+ wchar16_t key[8];
+} nt_keyed_object_directory_name, nt_keyed_objdir_name;
+
+
+typedef void nt_io_apc_routine(
+ void * apc_context,
+ nt_io_status_block * io_status_block,
+ uint32_t reserved);
+
+
+typedef int32_t __stdcall ntapi_zw_query_object(
+ __in void * handle,
+ __in nt_object_info_class obj_info_class,
+ __out void * obj_info,
+ __in size_t obj_info_length,
+ __out uint32_t * returned_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_set_information_object(
+ __in void * handle,
+ __in nt_object_info_class obj_info_class,
+ __in void * obj_info,
+ __in size_t obj_info_length);
+
+
+typedef int32_t __stdcall ntapi_zw_duplicate_object(
+ __in void * hprocess_src,
+ __in void * handle_src,
+ __in void * hprocess_dst,
+ __out void ** handle_dst __optional,
+ __in uint32_t desired_access,
+ __in uint32_t attributes,
+ __in uint32_t options);
+
+
+typedef int32_t __stdcall ntapi_zw_make_temporary_object(
+ __in void * handle);
+
+
+typedef int32_t __stdcall ntapi_zw_close(
+ __in void * handle);
+
+
+
+typedef int32_t __stdcall ntapi_zw_query_security_object(
+ __in void * handle,
+ __in nt_security_information security_info,
+ __out nt_security_descriptor * security_descriptor,
+ __in size_t security_descriptor_length,
+ __out size_t * returned_length);
+
+
+typedef int32_t __stdcall ntapi_zw_set_security_object(
+ __in void * handle,
+ __in nt_security_information security_info,
+ __out nt_security_descriptor * security_descriptor);
+
+
+
+typedef int32_t __stdcall ntapi_zw_create_directory_object(
+ __out void ** directory_handle,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_open_directory_object(
+ __out void ** directory_handle,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_query_directory_object(
+ __in void * directory_handle,
+ __out void * buffer,
+ __in size_t buffer_length,
+ __in int32_t return_single_entry,
+ __in int32_t return_scan,
+ __in_out uint32_t * context,
+ __out size_t * returned_length);
+
+
+typedef int32_t __stdcall ntapi_zw_create_symbolic_link_object(
+ __out void ** symbolic_link_handle,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __in nt_unicode_string * target_name);
+
+
+typedef int32_t __stdcall ntapi_zw_open_symbolic_link_object(
+ __out void ** symbolic_link_handle,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_query_symbolic_link_object(
+ __in void * symbolic_link_handle,
+ __in_out nt_unicode_string * target_name,
+ __out size_t * returned_length);
+
+/* extension functions */
+typedef int32_t __stdcall ntapi_tt_create_keyed_object_directory(
+ __out void ** hdir,
+ __in uint32_t desired_access,
+ __in const wchar16_t prefix[6],
+ __in nt_guid * guid,
+ __in uint32_t key);
+
+typedef int32_t __stdcall ntapi_tt_open_keyed_object_directory(
+ __out void ** hdir,
+ __in uint32_t desired_access,
+ __in const wchar16_t prefix[6],
+ __in nt_guid * guid,
+ __in uint32_t key);
+
+typedef int32_t __stdcall ntapi_tt_create_keyed_object_directory_entry(
+ __out void ** hentry,
+ __in uint32_t desired_access,
+ __in void * hdir,
+ __in void * htarget,
+ __in nt_unicode_string * target_name,
+ __in uint32_t key);
+
+#endif
diff --git a/include/ntapi/nt_os.h b/include/ntapi/nt_os.h
new file mode 100644
index 0000000..2ecd1d4
--- /dev/null
+++ b/include/ntapi/nt_os.h
@@ -0,0 +1,99 @@
+#ifndef _NT_OS_H_
+#define _NT_OS_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+
+
+typedef enum _nt_hard_error_response_option {
+ NT_OPTION_ABORT_RETRY_IGNORE,
+ NT_OPTION_OK_,
+ NT_OPTION_OK_CANCEL,
+ NT_OPTION_RETRY_CANCEL,
+ NT_OPTION_YES_NO,
+ NT_OPTION_YES_NO_CANCEL,
+ NT_OPTION_SHUTDOWN_SYSTEM
+} nt_hard_error_response_option;
+
+
+typedef enum _nt_hard_error_response {
+ NT_RESPONSE_RETURN_TO_CALLER,
+ NT_RESPONSE_NOT_HANDLED,
+ NT_RESPONSE_ABORT,
+ NT_RESPONSE_CANCEL,
+ NT_RESPONSE_IGNORE,
+ NT_RESPONSE_NO,
+ NT_RESPONSE_OK,
+ NT_RESPONSE_RETRY,
+ NT_RESPONSE_YES
+} nt_hard_error_response;
+
+
+typedef struct _nt_ldt_entry {
+ int32_t limit_low;
+ int32_t base_low;
+
+ union {
+ struct {
+ unsigned char base_mid;
+ unsigned char flags1;
+ unsigned char flags2;
+ unsigned char base_hi;
+ } bytes;
+
+ struct {
+ uint32_t base_mid :8;
+ uint32_t type :5;
+ uint32_t dpl :2;
+ uint32_t pres :1;
+ uint32_t limit_hi :4;
+ uint32_t sys :1;
+ uint32_t reserved :1;
+ uint32_t default_big :1;
+ uint32_t granularity :1;
+ uint32_t base_hi :8;
+ } bits;
+ } high_word;
+} nt_ldt_entry;
+
+
+typedef int32_t __stdcall ntapi_zw_flush_write_buffer(void);
+
+
+/* interface requires further studying */
+typedef int32_t __stdcall ntapi_zw_raise_hard_error(
+ __in int32_t status,
+ __in uint32_t number_of_args,
+ __in uint32_t string_arg_mask,
+ __in uint32_t * args,
+ __in nt_hard_error_response_option response_option,
+ __out nt_hard_error_response * response_received);
+
+
+typedef int32_t __stdcall ntapi_zw_set_default_hard_error_port(
+ __in void * hport);
+
+
+typedef int32_t __stdcall ntapi_zw_display_string(
+ __in nt_unicode_string * display_string);
+
+
+typedef int32_t __stdcall ntapi_zw_create_paging_file(
+ __in nt_unicode_string * file_name,
+ __in nt_large_integer * initial_size,
+ __in nt_large_integer * maximum_size,
+ __in uintptr_t reserved);
+
+
+typedef int32_t __stdcall ntapi_zw_set_ldt_entries(
+ __in uint32_t selector_1st,
+ __in nt_ldt_entry * ldt_entry_1st,
+ __in uint32_t selector_2nd,
+ __in nt_ldt_entry * ldt_entry_2nd);
+
+
+typedef int32_t __stdcall ntapi_zw_vdm_control(
+ __in uint32_t vdm_control_code,
+ __in void * vdm_control_data);
+
+#endif
diff --git a/include/ntapi/nt_pnp.h b/include/ntapi/nt_pnp.h
new file mode 100644
index 0000000..e806baf
--- /dev/null
+++ b/include/ntapi/nt_pnp.h
@@ -0,0 +1,326 @@
+#ifndef _NT_PNP_H_
+#define _NT_PNP_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+
+typedef enum _nt_latency_time {
+ NT_LT_DONT_CARE,
+ NT_LT_LOWEST_LATENCY
+} nt_latency_time;
+
+
+typedef enum _nt_device_power_state {
+ NT_POWER_DEVICE_UNSPECIFIED,
+ NT_POWER_DEVICE_D0,
+ NT_POWER_DEVICE_D1,
+ NT_POWER_DEVICE_D2,
+ NT_POWER_DEVICE_D3
+} nt_device_power_state;
+
+
+typedef enum _nt_power_action {
+ NT_POWER_ACTION_NONE,
+ NT_POWER_ACTION_RESERVED,
+ NT_POWER_ACTION_SLEEP,
+ NT_POWER_ACTION_HIBERNATE,
+ NT_POWER_ACTION_SHUTDOWN,
+ NT_POWER_ACTION_SHUTDOWN_RESET,
+ NT_POWER_ACTION_SHUTDOWN_OFF,
+} nt_power_action;
+
+
+typedef enum _nt_system_power_state {
+ NT_POWER_SYSTEM_UNSPECIFIED,
+ NT_POWER_SYSTEM_WORKING,
+ NT_POWER_SYSTEM_SLEEPING1,
+ NT_POWER_SYSTEM_SLEEPING2,
+ NT_POWER_SYSTEM_SLEEPING3,
+ NT_POWER_SYSTEM_HIBERNATE,
+ NT_POWER_SYSTEM_SHUTDOWN
+} nt_system_power_state;
+
+
+typedef enum _nt_power_info_level {
+ NT_SYSTEM_POWER_POLICY_AC,
+ NT_SYSTEM_POWER_POLICY_DC,
+ NT_VERIFY_SYSTEM_POLICY_AC,
+ NT_VERIFY_SYSTEM_POLICY_DC,
+ NT_SYSTEM_POWER_CAPABILITIES,
+ NT_SYSTEM_BATTERY_STATE,
+ NT_SYSTEM_POWER_STATE_HANDLER,
+ NT_PROCESSOR_STATE_HANDLER,
+ NT_SYSTEM_POWER_POLICY_CURRENT,
+ NT_ADMINISTRATOR_POWER_POLICY,
+ NT_SYSTEM_RESERVE_HIBER_FILE,
+ NT_PROCESSOR_INFORMATION,
+ NT_SYSTEM_POWER_INFORMATION
+} nt_power_info_level;
+
+
+/* execution state bits */
+#define NT_ES_SYSTEM_REQUIRED (0x00000001)
+#define NT_ES_DISPLAY_REQUIRED (0x00000002)
+#define NT_ES_USER_PRESENT (0x00000004)
+#define NT_ES_AWAYMODE_REQUIRED (0x00000040)
+#define NT_ES_CONTINUOUS (0x80000000)
+
+
+/* power action flag bits */
+#define NT_POWER_ACTION_QUERY_ALLOWED (0x00000001)
+#define NT_POWER_ACTION_UI_ALLOWED (0x00000002)
+#define NT_POWER_ACTION_OVERRIDE_APPS (0x00000004)
+#define NT_POWER_ACTION_LIGHTEST_FIRST (0x10000000)
+#define NT_POWER_ACTION_LOCK_CONSOLE (0x20000000)
+#define NT_POWER_ACTION_DISABLE_WAKES (0x40000000)
+#define NT_POWER_ACTION_CRITICAL (0x80000000)
+
+
+/* power state event codes */
+#define NT_POWER_LEVEL_USER_NOTIFY_TEXT (0x00000001)
+#define NT_POWER_LEVEL_USER_NOTIFY_SOUND (0x00000002)
+#define NT_POWER_LEVEL_USER_NOTIFY_EXEC (0x00000004)
+#define NT_POWER_USER_NOTIFY_BUTTON (0x00000008)
+#define NT_POWER_USER_NOTIFY_SHUTDOWN (0x00000010)
+#define NT_POWER_FORCE_TRIGGER_RESET (0x80000000)
+
+/* system power policy */
+#define NT_NUM_DISCHARGE_POLICIES (0x00000004)
+
+
+
+typedef struct _nt_power_action_policy {
+ nt_power_action action;
+ uint32_t action_flags;
+ uint32_t event_code;
+} nt_power_action_policy;
+
+
+typedef struct _nt_system_power_level {
+ unsigned char enable;
+ unsigned char padding[3];
+ uint32_t battery_level;
+ nt_power_action_policy power_policy;
+ nt_system_power_state min_system_state;
+} nt_system_power_level;
+
+
+typedef struct _nt_system_power_policy {
+ uint32_t revision;
+ nt_power_action_policy power_button;
+ nt_power_action_policy sleep_button;
+ nt_power_action_policy lid_close;
+ nt_system_power_state lid_open_wake;
+ uint32_t reserved_1st;
+ nt_power_action_policy idle;
+ uint32_t idle_timeout;
+ unsigned char idle_sensitivity;
+ unsigned char dynamic_throttle;
+ unsigned char padding[2];
+ nt_system_power_state min_sleep;
+ nt_system_power_state max_sleep;
+ nt_system_power_state reduced_latency_sleep;
+ uint32_t win_logon_flags;
+ uint32_t reserved_2nd;
+ uint32_t doze_s4_timeout;
+ uint32_t broadcast_capacity_resolution;
+ nt_system_power_level discharge_policy[NT_NUM_DISCHARGE_POLICIES];
+ uint32_t video_timeout;
+ unsigned char video_dim_display;
+ uint32_t video_reserved[3];
+ uint32_t spindown_timeout;
+ unsigned char optimize_for_power;
+ unsigned char fan_throttle_tolerance;
+ unsigned char forced_throttle;
+ unsigned char min_throttle;
+ nt_power_action_policy over_throttled;
+} nt_system_power_policy;
+
+
+typedef struct _nt_system_battery_state {
+ unsigned char ac_on_line;
+ unsigned char battery_present;
+ unsigned char charging;
+ unsigned char discharging;
+ unsigned char padding[4];
+ uint32_t max_capacity;
+ uint32_t remaining_capacity;
+ uint32_t rate;
+ uint32_t estimated_time;
+ uint32_t default_alert1;
+ uint32_t default_alert2;
+} nt_system_battery_state;
+
+
+typedef struct _nt_battery_reporting_scale {
+ uint32_t granularity;
+ uint32_t capacity;
+} nt_battery_reporting_scale;
+
+
+typedef struct _nt_system_power_capabilities {
+ unsigned char power_button_present;
+ unsigned char sleep_button_present;
+ unsigned char lid_present;
+ unsigned char system_s1;
+ unsigned char system_s2;
+ unsigned char system_s3;
+ unsigned char system_s4;
+ unsigned char system_s5;
+ unsigned char hiber_file_present;
+ unsigned char full_wake;
+ unsigned char video_dim_present;
+ unsigned char apm_present;
+ unsigned char ups_present;
+ unsigned char thermal_control;
+ unsigned char processor_throttle;
+ unsigned char processor_min_throttle;
+ unsigned char processor_max_throttle;
+ unsigned char fast_system_s4;
+ unsigned char hiber_boot;
+ unsigned char wake_alarm_present;
+ unsigned char ao_ac;
+ unsigned char disk_spin_down;
+ unsigned char padding[8];
+ unsigned char system_batteries_present;
+ unsigned char batteries_are_short_term;
+ nt_battery_reporting_scale battery_scale[3];
+ nt_system_power_state ac_on_line_wake;
+ nt_system_power_state soft_lid_wake;
+ nt_system_power_state rtc_wake;
+ nt_system_power_state min_device_wake_state;
+ nt_system_power_state default_low_latency_wake;
+} nt_system_power_capabilities;
+
+
+typedef struct _nt_system_power_information {
+ uint32_t max_idleness_allowed;
+ uint32_t idleness;
+ uint32_t time_remaining;
+ unsigned char cooling_mode;
+} nt_system_power_information;
+
+
+typedef struct _nt_system_power_status {
+ unsigned char ac_line_status;
+ unsigned char battery_flag;
+ unsigned char battery_life_percent;
+ unsigned char reserved;
+ uint32_t battery_life_time;
+ uint32_t battery_full_life_time;
+} nt_system_power_status;
+
+
+typedef struct _nt_administrator_power_policy {
+ nt_system_power_state min_sleep;
+ nt_system_power_state max_sleep;
+ uint32_t min_video_timeout;
+ uint32_t max_video_timeout;
+ uint32_t min_spindown_timeout;
+ uint32_t max_spindown_timeout;
+} nt_administrator_power_policy;
+
+
+typedef struct _nt_user_power_policy {
+ uint32_t revision;
+ nt_power_action_policy idle_ac;
+ nt_power_action_policy idle_dc;
+ uint32_t idle_timeout_ac;
+ uint32_t idle_timeout_dc;
+ unsigned char idle_sensitivity_ac;
+ unsigned char idle_sensitivity_dc;
+ unsigned char throttle_policy_ac;
+ unsigned char throttle_policy_dc;
+ nt_system_power_state max_sleep_ac;
+ nt_system_power_state max_sleep_dc;
+ uint32_t reserved[2];
+ uint32_t video_timeout_ac;
+ uint32_t video_timeout_dc;
+ uint32_t spindown_timeout_ac;
+ uint32_t spindown_timeout_dc;
+ unsigned char optimize_for_power_ac;
+ unsigned char optimize_for_power_dc;
+ unsigned char fan_throttle_tolerance_ac;
+ unsigned char fan_throttle_tolerance_dc;
+ unsigned char forced_throttle_ac;
+ unsigned char forced_throttle_dc;
+} nt_user_power_policy;
+
+
+typedef struct _nt_processor_power_information {
+ uint32_t number;
+ uint32_t max_mhz;
+ uint32_t current_mhz;
+ uint32_t mhz_limit;
+ uint32_t max_idle_state;
+ uint32_t current_idle_state;
+} nt_processor_power_information;
+
+
+typedef struct _nt_plug_play_notification_header {
+ uint16_t version;
+ uint16_t size;
+ nt_guid event;
+} nt_plug_play_notification_header;
+
+
+/* ZwRequestWakeupLatency: no longer present */
+typedef int32_t __stdcall ntapi_zw_request_wakeup_latency(
+ __in nt_latency_time latency);
+
+
+/* ZwRequestDeviceWakeup: no longer present */
+typedef int32_t __stdcall ntapi_zw_request_device_wakeup(
+ __in void * hdevice);
+
+
+/* ZwCancelDeviceWakeupRequest: no longer present */
+typedef int32_t __stdcall ntapi_zw_cancel_device_wakeup_request(
+ __in void * hdevice);
+
+
+typedef int32_t __stdcall ntapi_zw_is_system_resume_automatic(void);
+
+
+typedef int32_t __stdcall ntapi_zw_set_thread_execution_state(
+ __in uint32_t execution_state,
+ __out uint32_t * prev_execution_state);
+
+
+typedef int32_t __stdcall ntapi_zw_get_device_power_state(
+ __in void * hdevice,
+ __out nt_device_power_state * device_power_state);
+
+
+typedef int32_t __stdcall ntapi_zw_set_system_power_state(
+ __in nt_power_action system_action,
+ __in nt_system_power_state min_system_state,
+ __in uint32_t system_power_state_flags);
+
+
+typedef int32_t __stdcall ntapi_zw_initiate_power_action(
+ __in nt_power_action system_action,
+ __in nt_system_power_state min_system_statem,
+ __in uint32_t system_power_state_flags,
+ __in unsigned char async);
+
+typedef int32_t __stdcall ntapi_zw_power_information(
+ __in nt_power_info_level power_info_level,
+ __in void * input_buffer __optional,
+ __in uint32_t input_buffer_length,
+ __out void * output_buffer __optional,
+ __in uint32_t output_buffer_length);
+
+
+typedef int32_t __stdcall ntapi_zw_plug_play_control(
+ __in uint32_t pnp_control_code,
+ __in_out void * buffer,
+ __in uint32_t buffer_length);
+
+typedef int32_t __stdcall ntapi_zw_get_plug_play_event(
+ __in uint32_t reserved_1st,
+ __in uint32_t reserved_2nd,
+ __out void * buffer,
+ __in uint32_t buffer_length);
+
+#endif
diff --git a/include/ntapi/nt_port.h b/include/ntapi/nt_port.h
new file mode 100644
index 0000000..beb4f32
--- /dev/null
+++ b/include/ntapi/nt_port.h
@@ -0,0 +1,332 @@
+#ifndef _NT_PORT_H_
+#define _NT_PORT_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+#include "nt_process.h"
+
+typedef enum _nt_lpc_type {
+ NT_LPC_NEW_MESSAGE = 0,
+ NT_LPC_REQUEST = 1,
+ NT_LPC_REPLY = 2,
+ NT_LPC_DATAGRAM = 3,
+ NT_LPC_LOST_REPLY = 4,
+ NT_LPC_PORT_CLOSED = 5,
+ NT_LPC_CLIENT_DIED = 6,
+ NT_LPC_EXCEPTION = 7,
+ NT_LPC_DEBUG_EVENT = 8,
+ NT_LPC_ERROR_EVENT = 9,
+ NT_LPC_CONNECTION_REQUEST = 10,
+ NT_ALPC_REQUEST = 0x2000 | NT_LPC_REQUEST,
+ NT_ALPC_CONNECTION_REQUEST = 0x2000 | NT_LPC_CONNECTION_REQUEST,
+} nt_lpc_type;
+
+
+typedef enum _nt_port_info_class {
+ NT_PORT_BASIC_INFORMATION
+} nt_port_info_class;
+
+
+/* friendly port types */
+typedef enum _nt_port_type {
+ NT_PORT_TYPE_DEFAULT, /* {'s','v','c','a','n','y'} */
+ NT_PORT_TYPE_SUBSYSTEM, /* {'n','t','c','t','t','y'} */
+ NT_PORT_TYPE_VMOUNT, /* {'v','m','o','u','n','t'} */
+ NT_PORT_TYPE_DAEMON, /* {'d','a','e','m','o','n'} */
+ NT_PORT_TYPE_CAP
+} nt_port_type;
+
+
+typedef enum _nt_port_subtype {
+ NT_PORT_SUBTYPE_DEFAULT,
+ NT_PORT_SUBTYPE_PRIVATE,
+ NT_PORT_SUBTYPE_CAP
+} nt_port_subtype;
+
+
+/* friendly port guids */
+#define NT_PORT_GUID_DEFAULT {0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}
+#define NT_PORT_GUID_SUBSYSTEM {0xce7f8d40,0x81cd,0x41c6,{0xa4,0xb7,0xb8,0x35,0x67,0xdf,0x15,0xd9}}
+#define NT_PORT_GUID_VMOUNT {0x893d63d2,0x23e8,0x4caa,{0xa8,0x41,0x7f,0x6e,0x77,0x6b,0xd5,0x70}}
+#define NT_PORT_GUID_DAEMON {0xcf765d9e,0x6bd8,0x4a8d,{0x8a,0x21,0x17,0x34,0xcd,0x3a,0x8d,0xa7}}
+
+/* lpc messages */
+#define NT_LPC_REFUSE_CONNECTION 0x0000
+#define NT_LPC_ACCEPT_CONNECTION 0x0001
+#define NT_LPC_MAX_MSG_DATA_SIZE 0x0104
+
+
+typedef struct _nt_port_basic_information {
+ void * dummy_invalid;
+} nt_port_basic_information;
+
+
+typedef struct _nt_port_message {
+ uint16_t data_size;
+ uint16_t msg_size;
+ uint16_t msg_type;
+ uint16_t virtual_ranges_offset;
+ nt_client_id client_id;
+ uint32_t msg_id;
+ size_t section_size;
+} nt_port_message;
+
+
+/* csrss port message structure: new process, first thread */
+typedef struct _nt_port_message_csrss_process {
+ nt_port_message header;
+ uintptr_t unknown_1st;
+ uint32_t opcode;
+ int32_t status;
+ uintptr_t unknown_2nd;
+ void * hprocess;
+ void * hthread;
+ uintptr_t unique_process_id;
+ uintptr_t unique_thread_id;
+ void * reserved[8];
+} nt_port_message_csrss_process;
+
+/* csrss port message structure: existing process, new thread */
+typedef struct _nt_port_message_csrss_thread {
+ nt_port_message header;
+ uintptr_t unknown_1st;
+ uint32_t opcode;
+ int32_t status;
+ uintptr_t unknown_2nd;
+ void * hthread;
+ uintptr_t unique_process_id;
+ uintptr_t unique_thread_id;
+ void * reserved[8];
+} nt_port_message_csrss_thread;
+
+
+typedef struct _nt_port_section_write {
+ uint32_t length;
+ void * hsection;
+ uint32_t offset;
+ size_t view_size;
+ void * view_base;
+ void * target_vew_base;
+} nt_port_section_write;
+
+
+typedef struct _nt_port_section_read {
+ uint32_t length;
+ size_t view_size;
+ void * view_base;
+} nt_port_section_read;
+
+
+/* attributes of a friendly port */
+typedef struct _nt_port_keys {
+ uint32_t reserved;
+ uint32_t key[6];
+ uint32_t padding;
+} nt_port_keys;
+
+typedef struct _nt_port_attr {
+ nt_guid guid;
+ nt_port_type type;
+ nt_port_subtype subtype;
+ int32_t ver_major;
+ int32_t ver_minor;
+ uint32_t options;
+ uint32_t flags;
+ nt_port_keys keys;
+} nt_port_attr;
+
+
+/* guid component of a friendly port name */
+typedef struct _nt_port_guid {
+ wchar16_t uscore_guid;
+ wchar16_t port_guid[36];
+ wchar16_t uscore_keys;
+} nt_port_guid;
+
+/* keys component of a friendly port name */
+typedef struct _nt_port_name_keys {
+ wchar16_t key_1st[8];
+ wchar16_t uscore_1st;
+ wchar16_t key_2nd[8];
+ wchar16_t uscore_2nd;
+ wchar16_t key_3rd[8];
+ wchar16_t uscore_3rd;
+ wchar16_t key_4th[8];
+ wchar16_t uscore_4th;
+ wchar16_t key_5th[8];
+ wchar16_t uscore_5th;
+ wchar16_t key_6th[8];
+} nt_port_name_keys;
+
+
+/* friendly port name */
+typedef struct _nt_port_name {
+ wchar16_t base_named_objects[17];
+ wchar16_t backslash;
+ wchar16_t svc_prefix[6];
+ nt_port_guid port_guid;
+ nt_port_name_keys port_name_keys;
+ wchar16_t null_termination;
+} nt_port_name;
+
+
+typedef int32_t __stdcall ntapi_zw_create_port(
+ __out void ** hport,
+ __in nt_object_attributes * obj_attr,
+ __out uint32_t max_data_size,
+ __out uint32_t max_msg_size,
+ __in_out uint32_t reserved);
+
+
+typedef int32_t __stdcall ntapi_zw_create_waitable_port(
+ __out void ** hport,
+ __in nt_object_attributes * obj_attr,
+ __out uint32_t max_data_size,
+ __out uint32_t max_msg_size,
+ __in_out uint32_t reserved);
+
+
+typedef int32_t __stdcall ntapi_zw_connect_port(
+ __out void ** hport,
+ __in nt_unicode_string * port_name,
+ __in nt_security_quality_of_service * sec_qos,
+ __in_out nt_port_section_write * write_section __optional,
+ __in_out nt_port_section_read * read_section __optional,
+ __out uint32_t * max_msg_size __optional,
+ __in_out void * msg_data __optional,
+ __in_out uint32_t * msg_data_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_secure_connect_port(
+ __out void ** hport,
+ __in nt_unicode_string * port_name,
+ __in nt_security_quality_of_service * sec_qos,
+ __in_out nt_port_section_write * write_section __optional,
+ __in nt_sid * server_dis __optional,
+ __in_out nt_port_section_read * read_section __optional,
+ __out uint32_t * max_msg_size __optional,
+ __in_out void * msg_data __optional,
+ __in_out uint32_t * msg_data_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_listen_port(
+ __in void * hport,
+ __in nt_port_message * port_message);
+
+
+typedef int32_t __stdcall ntapi_zw_accept_connect_port(
+ __out void ** hport,
+ __in intptr_t port_id,
+ __in nt_port_message * port_message,
+ __in int32_t response,
+ __out nt_port_section_write * write_section __optional,
+ __out nt_port_section_read * read_section __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_complete_connect_port(
+ __in void * hport);
+
+
+typedef int32_t __stdcall ntapi_zw_request_port(
+ __in void * hport,
+ __in void * request_msg);
+
+
+typedef int32_t __stdcall ntapi_zw_request_wait_reply_port(
+ __in void * hport,
+ __in void * request_msg,
+ __out void * reply_msg);
+
+
+typedef int32_t __stdcall ntapi_zw_reply_port(
+ __in void * hport,
+ __in nt_port_message * reply_message);
+
+
+typedef int32_t __stdcall ntapi_zw_reply_wait_reply_port(
+ __in void * hport,
+ __in_out nt_port_message * reply_message);
+
+
+typedef int32_t __stdcall ntapi_zw_reply_wait_receive_port(
+ __in void * hport,
+ __out intptr_t * port_id __optional,
+ __in nt_port_message * reply_message __optional,
+ __out nt_port_message * receive_message);
+
+
+typedef int32_t __stdcall ntapi_zw_reply_wait_receive_port_ex(
+ __in void * hport,
+ __out intptr_t * port_id __optional,
+ __in nt_port_message * reply_message __optional,
+ __out nt_port_message * receive_message,
+ __in nt_large_integer * timeout);
+
+typedef int32_t __stdcall ntapi_zw_read_request_data(
+ __in void * hport,
+ __in nt_port_message * message,
+ __in uint32_t index,
+ __out void * buffer,
+ __in size_t buffer_length,
+ __out size_t * returned_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_write_request_data(
+ __in void * hport,
+ __in nt_port_message * message,
+ __in uint32_t index,
+ __in void * buffer,
+ __in size_t buffer_length,
+ __out size_t * returned_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_query_information_port(
+ __in void * hport,
+ __in nt_port_info_class port_info_class,
+ __out void * port_info,
+ __in size_t port_info_length,
+ __out size_t * returned_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_impersonate_client_of_port(
+ __in void * hport,
+ __in nt_port_message * message);
+
+
+typedef int32_t __stdcall ntapi_csr_client_call_server(
+ __in void * msg_csrss,
+ __in void * msg_unknown,
+ __in uint32_t msg_opcode,
+ __in uint32_t msg_size);
+
+
+typedef void * __cdecl ntapi_csr_port_handle(int32_t * pstatus);
+
+
+/* extensions */
+typedef int32_t __stdcall ntapi_tt_port_guid_from_type(
+ __out nt_guid * guid,
+ __in nt_port_type type,
+ __in nt_port_subtype subtype);
+
+
+typedef int32_t __stdcall ntapi_tt_port_type_from_guid(
+ __out nt_port_type * type,
+ __out nt_port_subtype * subtype,
+ __in nt_guid * guid);
+
+
+typedef int32_t __stdcall ntapi_tt_port_generate_keys(
+ __out nt_port_keys * keys);
+
+
+typedef void __stdcall ntapi_tt_port_format_keys(
+ __in nt_port_keys * keys,
+ __out nt_port_name_keys * name_keys);
+
+
+typedef void __stdcall ntapi_tt_port_name_from_attributes(
+ __out nt_port_name * name,
+ __in nt_port_attr * attr);
+
+#endif
diff --git a/include/ntapi/nt_process.h b/include/ntapi/nt_process.h
new file mode 100644
index 0000000..61afdb5
--- /dev/null
+++ b/include/ntapi/nt_process.h
@@ -0,0 +1,676 @@
+#ifndef _NT_PROCESS_H_
+#define _NT_PROCESS_H_
+
+#include <psxtypes/psxtypes.h>
+#include <pemagine/pemagine.h>
+#include "nt_object.h"
+#include "nt_memory.h"
+#include "nt_section.h"
+
+typedef enum _nt_process_info_class {
+ NT_PROCESS_BASIC_INFORMATION,
+ NT_PROCESS_QUOTA_LIMITS,
+ NT_PROCESS_IO_COUNTERS,
+ NT_PROCESS_VM_COUNTERS,
+ NT_PROCESS_TIMES,
+ NT_PROCESS_BASE_PRIORITY,
+ NT_PROCESS_RAISE_PRIORITY,
+ NT_PROCESS_DEBUG_PORT,
+ NT_PROCESS_EXCEPTION_PORT,
+ NT_PROCESS_ACCESS_TOKEN,
+ NT_PROCESS_LDT_INFORMATION,
+ NT_PROCESS_LDT_SIZE,
+ NT_PROCESS_DEFAULT_HARD_ERROR_MODE,
+ NT_PROCESS_IO_PORT_HANDLERS,
+ NT_PROCESS_POOLED_USAGE_AND_LIMITS,
+ NT_PROCESS_WORKING_SET_WATCH,
+ NT_PROCESS_USER_MODE_IOPL,
+ NT_PROCESS_ENABLE_ALIGNMENT_FAULT_FIXUP,
+ NT_PROCESS_PRIORITY_CLASS,
+ NT_PROCESS_WX86_INFORMATION,
+ NT_PROCESS_HANDLE_COUNT,
+ NT_PROCESS_AFFINITY_MASK,
+ NT_PROCESS_PRIORITY_BOOST,
+ NT_PROCESS_DEVICE_MAP,
+ NT_PROCESS_SESSION_INFORMATION,
+ NT_PROCESS_FOREGROUND_INFORMATION,
+ NT_PROCESS_WOW64_INFORMATION,
+ NT_PROCESS_IMAGE_FILE_NAME
+} nt_process_info_class;
+
+
+typedef enum _nt_process_create_info_class {
+ NT_PROCESS_CREATE_INITIAL_STATE,
+ NT_PROCESS_CREATE_FAIL_ON_FILE_OPEN,
+ NT_PROCESS_CREATE_FAIL_ON_SECTION_CREATE,
+ NT_PROCESS_CREATE_FAIL_EXE_FORMAT,
+ NT_PROCESS_CREATE_FAIL_MACHINE_MISMATCH,
+ NT_PROCESS_CREATE_FAIL_EXE_NAME,
+ NT_PROCESS_CREATE_SUCCESS,
+ NT_PROCESS_CREATE_MAXIMUM_STATES,
+} nt_process_create_info_class;
+
+
+
+/* special handles */
+#define NT_CURRENT_PROCESS_HANDLE (void *)(uintptr_t)-1
+
+
+/* process access bits */
+#define NT_PROCESS_CREATE_PROCESS 0x00000080U
+#define NT_PROCESS_CREATE_THREAD 0x00000002U
+#define NT_PROCESS_DUP_HANDLE 0x00000040U
+#define NT_PROCESS_QUERY_INFORMATION 0x00000400U
+#define NT_PROCESS_SET_INFORMATION 0x00000200U
+#define NT_PROCESS_SET_QUOTA 0x00000100U
+#define NT_PROCESS_SUSPEND_RESUME 0x00000800U
+#define NT_PROCESS_TERMINATE 0x00000001U
+#define NT_PROCESS_VM_OPERATION 0x00000008U
+#define NT_PROCESS_VM_READ 0x00000010U
+#define NT_PROCESS_VM_WRITE 0x00000020U
+#define NT_PROCESS_SYNCHRONIZE 0x00100000U
+#define NT_PROCESS_PRESERVE_AUTHZ_LEVEL 0x02000000U
+#define NT_PROCESS_ALL_ACCESS NT_PROCESS_CREATE_PROCESS \
+ | NT_PROCESS_CREATE_THREAD \
+ | NT_PROCESS_DUP_HANDLE \
+ | NT_PROCESS_QUERY_INFORMATION \
+ | NT_PROCESS_SET_INFORMATION \
+ | NT_PROCESS_SET_QUOTA \
+ | NT_PROCESS_SUSPEND_RESUME \
+ | NT_PROCESS_TERMINATE \
+ | NT_PROCESS_VM_OPERATION \
+ | NT_PROCESS_VM_READ \
+ | NT_PROCESS_VM_WRITE \
+ | NT_PROCESS_SYNCHRONIZE
+
+
+
+/* set error mode */
+#define NT_SEM_FAIL_CRITICAL_ERRORS 0x0001
+#define NT_SEM_NO_GP_FAULT_ERROR_BOX 0x0002
+#define NT_SEM_NO_ALIGNMENT_FAULT_EXCEPT 0x0004
+#define NT_SEM_NO_OPEN_FILE_ERROR_BOX 0x8000
+
+
+/* process priority class (information class) */
+#define NT_PC_IDLE 0x00
+#define NT_PC_NORMAL 0x02
+#define NT_PC_HIGH 0x03
+#define NT_PC_REALTIME 0x04
+#define NT_PC_BELOW_NORMAL 0x05
+#define NT_PC_ABOVE_NORMAL 0x05
+
+
+/* process device map drive type */
+#define NT_DRIVE_UNKNOWN 0x00
+#define NT_NO_ROOT_DIR 0x01
+#define NT_DRIVE_REMOVABLE 0x02
+#define NT_DRIVE_FIXED 0x03
+#define NT_DRIVE_REMOTE 0x04
+#define NT_DRIVE_CDROM 0x05
+#define NT_DRIVE_RAMDISK 0x06
+
+
+/* process debug info class mask */
+#define NT_PDI_MODULES 0x0001
+#define NT_PDI_BACKTRACE 0x0002
+#define NT_PDI_HEAPS 0x0004
+#define NT_PDI_HEAP_TAGS 0x0008
+#define NT_PDI_HEAP_BLOCKS 0x0010
+#define NT_PDI_LOCKS 0x0020
+
+
+/* process debug module information flags */
+#define NT_LDRP_STATIC_LINK 0x00000002
+#define NT_LDRP_IMAGE_DLL 0x00000004
+#define NT_LDRP_LOAD_IN_PROGRESS 0x00001000
+#define NT_LDRP_UNLOAD_IN_PROGRESS 0x00002000
+#define NT_LDRP_ENTRY_PROCESSED 0x00004000
+#define NT_LDRP_ENTRY_INSERTED 0x00008000
+#define NT_LDRP_CURRENT_LOAD 0x00010000
+#define NT_LDRP_FAILED_BUILTIN_LOAD 0x00020000
+#define NT_LDRP_DONT_CALL_FOR_THREADS 0x00040000
+#define NT_LDRP_PROCESS_ATTACH_CALLED 0x00080000
+#define NT_LDRP_DEBUG_SYMBOLS_LOADED 0x00100000
+#define NT_LDRP_IMAGE_NOT_AT_BASE 0x00200000
+#define NT_LDRP_WX86_IGNORE_MACHINETYPE 0x00400000
+
+
+/* create process info bits */
+#define NT_PROCESS_CREATE_INFO_WRITE_OUTPUT 0x00000001
+#define NT_PROCESS_CREATE_INFO_OBTAIN_OUTPUT 0x20000003
+
+/* zw_create_user_process: creation flags */
+#define NT_PROCESS_CREATE_FLAGS_CREATE_THREAD_SUSPENDED (0x00000001)
+#define NT_PROCESS_CREATE_FLAGS_RESET_DEBUG_PORT (0x00000002)
+#define NT_PROCESS_CREATE_FLAGS_INHERIT_HANDLES (0x00000004)
+#define NT_PROCESS_CREATE_FLAGS_NO_OBJECT_SYNC (0x00000100)
+
+/* zw_create_user_process: extended parameters */
+#define NT_CREATE_PROCESS_EXT_PARAM_SET_FILE_NAME (0x00020005)
+#define NT_CREATE_PROCESS_EXT_PARAM_SET_VIRTUAL_ADDR_RANGES (0x00020007)
+#define NT_CREATE_PROCESS_EXT_PARAM_SET_BASE_PRIORITY (0x00020008)
+#define NT_CREATE_PROCESS_EXT_PARAM_SET_HARD_ERROR_MODE (0x00020009)
+#define NT_CREATE_PROCESS_EXT_PARAM_SET_CONSOLE_FLAGS (0x0002000A)
+#define NT_CREATE_PROCESS_EXT_PARAM_SET_INHERITED_HANDLES (0x0002000B)
+#define NT_CREATE_PROCESS_EXT_PARAM_SET_PARENT (0x00060000)
+#define NT_CREATE_PROCESS_EXT_PARAM_SET_DEBUG (0x00060001)
+#define NT_CREATE_PROCESS_EXT_PARAM_SET_TOKEN (0x00060002)
+
+#define NT_CREATE_PROCESS_EXT_PARAM_GET_SECTION_IMAGE_INFO (0x00000006)
+#define NT_CREATE_PROCESS_EXT_PARAM_GET_CLIENT_ID (0x00010003)
+#define NT_CREATE_PROCESS_EXT_PARAM_GET_TEB_ADDRESS (0x00010004)
+
+
+/* zw_create_user_process: console flag bits */
+#define NT_CREATE_PROCESS_EXT_CONSOLE_FLAG_DEFAULT (0x00)
+#define NT_CREATE_PROCESS_EXT_CONSOLE_FLAG_DO_NOT_USE_HANDLES (0x00)
+#define NT_CREATE_PROCESS_EXT_CONSOLE_FLAG_INHERIT_HANDLES (0x01)
+#define NT_CREATE_PROCESS_EXT_CONSOLE_FLAG_USE_ARG_HANDLES (0x02)
+#define NT_CREATE_PROCESS_EXT_CONSOLE_FLAG_INHERIT_STDIN (0x04)
+#define NT_CREATE_PROCESS_EXT_CONSOLE_FLAG_INHERIT_STDOUT (0x08)
+#define NT_CREATE_PROCESS_EXT_CONSOLE_FLAG_INHERIT_STDERR (0x10)
+
+/* nt_runtime_data_block flag bits */
+#define NT_RUNTIME_DATA_DUPLICATE_SESSION_HANDLES (0x01)
+
+/* tt_get_runtime_data flag bits */
+#define NT_RUNTIME_DATA_ALLOW_BUILTIN_DEFAULT (0x01)
+
+/* runtime data convenience storage */
+#define NT_RUNTIME_DATA_USER_PTRS (0x10)
+#define NT_RUNTIME_DATA_USER_INT32_SLOTS (0x10)
+#define NT_RUNTIME_DATA_USER_INT64_SLOTS (0x10)
+
+/* friendly process guids */
+#define NT_PROCESS_GUID_NTPGRP {0xfa383cc0,0xa25b,0x4448,{0x83,0x45,0x51,0x45,0x4d,0xa8,0x2f,0x30}}
+#define NT_PROCESS_GUID_PIDMAP {0xba054c90,0x8b4f,0x4989,{0xa0,0x52,0x32,0xce,0x41,0x9e,0xbf,0x97}}
+#define NT_PROCESS_GUID_PIDANY {0x431bf6a6,0x65c4,0x4eb0,{0x88,0xca,0x16,0xfe,0xc0,0x18,0xc8,0xb7}}
+
+/* friendly process object directory prefixes */
+#define NT_PROCESS_OBJDIR_PREFIX_NTPGRP {'n','t','p','g','r','p'}
+#define NT_PROCESS_OBJDIR_PREFIX_PIDMAP {'p','i','d','m','a','p'}
+#define NT_PROCESS_OBJDIR_PREFIX_PIDANY {'p','i','d','a','n','y'}
+
+typedef struct _nt_process_information {
+ void * hprocess;
+ void * hthread;
+ uintptr_t process_id;
+ uintptr_t thread_id;
+} nt_process_information, nt_process_info;
+
+
+typedef struct _nt_process_parameters {
+ uint32_t alloc_size;
+ uint32_t used_size;
+ uint32_t flags;
+ uint32_t reserved;
+ void * hconsole;
+ uintptr_t console_flags;
+ void * hstdin;
+ void * hstdout;
+ void * hstderr;
+ nt_unicode_string cwd_name;
+ void * cwd_handle;
+ nt_unicode_string __attr_ptr_size_aligned__ dll_path;
+ nt_unicode_string __attr_ptr_size_aligned__ image_file_name;
+ nt_unicode_string __attr_ptr_size_aligned__ command_line;
+ wchar16_t * environment;
+ uint32_t dwx;
+ uint32_t dwy;
+ uint32_t dwx_size;
+ uint32_t dwy_size;
+ uint32_t dwx_count_chars;
+ uint32_t dwy_count_chars;
+ uint32_t dw_fill_attribute;
+ uint32_t dw_flags;
+ uint32_t wnd_show;
+ nt_unicode_string wnd_title;
+ nt_unicode_string __attr_ptr_size_aligned__ desktop;
+ nt_unicode_string __attr_ptr_size_aligned__ shell_info;
+ nt_unicode_string __attr_ptr_size_aligned__ runtime_data;
+} nt_process_parameters;
+
+
+typedef struct _nt_peb {
+ unsigned char reserved_1st[2];
+ unsigned char debugged;
+ unsigned char reserved_2nd[1];
+ void * reserved_3rd[2];
+ struct pe_peb_ldr_data* peb_ldr_data;
+ nt_process_parameters * process_params;
+ unsigned char reserved_4th[104];
+ void * reserved_5th[52];
+ void * post_process_init_routine;
+ unsigned char reserved_6th[128];
+ void * reserved_7th[1];
+ uint32_t session_id;
+} nt_peb;
+
+
+typedef struct _nt_process_basic_information {
+ int32_t exit_status;
+ nt_peb * peb_base_address;
+ intptr_t affinity_mask;
+ uint32_t base_priority;
+ uintptr_t unique_process_id;
+ uintptr_t inherited_from_unique_process_id;
+} nt_process_basic_information, nt_pbi;
+
+
+typedef struct _nt_process_access_token {
+ void * token;
+ void * thread;
+} nt_process_access_token;
+
+
+typedef struct _nt_process_ws_watch_information {
+ void * faulting_pc;
+ void * faulting_va;
+} nt_process_ws_watch_information;
+
+
+typedef struct _nt_process_priority_class {
+ int32_t foreground;
+ uint32_t priority;
+} nt_process_priority_class;
+
+
+typedef struct _nt_process_device_map_information {
+ union {
+ struct {
+ void * directory_handle;
+ } set;
+
+ struct {
+ uint32_t drive_map;
+ unsigned char drive_type[32];
+ } query;
+ };
+} nt_process_device_map_information;
+
+
+typedef struct _nt_debug_buffer {
+ void * hsection;
+ void * section_base;
+ void * remote_section_base;
+ size_t section_base_delta;
+ void * hevent_pair;
+ void * unknown[2];
+ void * hthread_remote;
+ uint32_t info_class_mask;
+ size_t info_size;
+ size_t allocated_size;
+ size_t section_size;
+ void * module_information;
+ void * back_trace_information;
+ void * heap_information;
+ void * lock_information;
+ void * reserved[8];
+} nt_debug_buffer;
+
+
+typedef struct _nt_debug_module_information {
+ void * reserved[2];
+ size_t base;
+ size_t size;
+ uint32_t flags;
+ uint16_t index;
+ uint16_t unknown;
+ uint16_t load_count;
+ uint16_t module_name_offset;
+ char image_name[256];
+} nt_debug_module_information;
+
+
+typedef struct _nt_debug_heap_information {
+ size_t base;
+ uint32_t flags;
+ uint16_t granularity;
+ uint16_t unknown;
+ size_t allocated;
+ size_t committed;
+ uint32_t tag_count;
+ uint32_t block_count;
+ void * reserved[7];
+ void * tags;
+ void * blocks;
+} nt_debug_heap_information;
+
+
+typedef struct _nt_debug_lock_information {
+ void * address;
+ uint16_t type;
+ uint16_t creator_back_trace_index;
+ uintptr_t owner_thread_id;
+ uint32_t active_count;
+ uint32_t contention_count;
+ uint32_t entry_count;
+ uint32_t recursion_count;
+ uint32_t number_of_share_waiters;
+ uint32_t number_of_exclusive_waiters;
+} nt_debug_lock_information;
+
+
+typedef struct _nt_executable_image {
+ void * hfile;
+ void * hsection;
+ void * addr;
+ size_t size;
+ uint16_t characteristics;
+ uint16_t magic;
+ uint16_t subsystem;
+ uint16_t uflags;
+} nt_executable_image;
+
+
+typedef struct _nt_process_session_information {
+ uintptr_t session_id;
+} nt_process_session_information;
+
+
+typedef struct _nt_create_process_info {
+ size_t size;
+ size_t state;
+
+ union {
+ struct {
+ uint32_t init_flags;
+ uint32_t file_access_ext;
+ uintptr_t unused[8];
+ } init_state;
+
+ struct {
+ uintptr_t output_flags;
+ void * hfile;
+ void * hsection;
+ uint64_t unknown[6];
+ } success_state;
+ };
+} nt_create_process_info;
+
+
+typedef struct _nt_create_process_ext_param {
+ size_t ext_param_type;
+ size_t ext_param_size;
+
+ union {
+ uint32_t ext_param_value;
+ void * ext_param_addr;
+ };
+
+ size_t ext_param_returned_length;
+} nt_create_process_ext_param;
+
+
+typedef struct _nt_create_process_ext_params {
+ size_t ext_params_size;
+ nt_create_process_ext_param ext_param[];
+} nt_create_process_ext_params;
+
+
+typedef struct _nt_user_process_info {
+ uint32_t size;
+ void * hprocess;
+ void * hthread;
+ nt_cid cid;
+ nt_section_image_information sec_image_info;
+} nt_user_process_info;
+
+
+typedef struct _nt_process_alternate_client_id {
+ void * hpgrp;
+ void * hentry;
+ void * hsession;
+ void * hdaemon;
+ void * htarget;
+ void * hevent;
+ int32_t tid;
+ int32_t pid;
+ int32_t pgid;
+ int32_t sid;
+ uintptr_t reserved[8];
+} nt_process_alternate_client_id, nt_alt_cid;
+
+typedef struct _nt_runtime_data {
+ void * hprocess_self;
+ void * hprocess_parent;
+ nt_cid cid_self;
+ nt_cid cid_parent;
+ nt_alt_cid alt_cid_self;
+ nt_alt_cid alt_cid_parent;
+ void * himage;
+ void * hroot;
+ void * hcwd;
+ void * hdrive;
+ void * hstdin;
+ void * hstdout;
+ void * hstderr;
+ void * hjob;
+ void * hsession;
+ void * hdebug;
+ void * hlog;
+ void * hready;
+ void * srv_ready;
+ nt_guid srv_guid;
+ int32_t srv_type;
+ int32_t srv_subtype;
+ uint32_t srv_keys[6];
+ int32_t stdin_type;
+ int32_t stdout_type;
+ int32_t stderr_type;
+ int32_t session_type;
+ uint32_t dbg_type;
+ uint32_t log_type;
+ void * ctx_hsection;
+ void * ctx_addr;
+ size_t ctx_size;
+ size_t ctx_commit;
+ ptrdiff_t ctx_offset;
+ size_t ctx_counter;
+ size_t ctx_meta_size;
+ size_t ctx_buffer_size;
+ uint32_t ctx_options;
+ uint32_t ctx_flags;
+ uint32_t meta_hash;
+ uint32_t block_hash;
+ size_t stack_reserve;
+ size_t stack_commit;
+ size_t heap_reserve;
+ size_t heap_commit;
+ int32_t envc;
+ int32_t argc;
+ char ** argv;
+ char ** envp;
+ wchar16_t ** wargv;
+ wchar16_t ** wenvp;
+ int32_t peb_envc;
+ int32_t peb_argc;
+ wchar16_t ** peb_wargv;
+ wchar16_t ** peb_wenvp;
+ void * uptr [NT_RUNTIME_DATA_USER_PTRS];
+ void * uclose[NT_RUNTIME_DATA_USER_PTRS];
+ int32_t udat32[NT_RUNTIME_DATA_USER_INT32_SLOTS];
+ int64_t udat64[NT_RUNTIME_DATA_USER_INT64_SLOTS];
+ uintptr_t buffer[];
+} nt_runtime_data, nt_rtdata;
+
+
+typedef struct _nt_runtime_data_block {
+ void * addr;
+ size_t size;
+ void * remote_addr;
+ size_t remote_size;
+ int32_t flags;
+} nt_runtime_data_block;
+
+
+typedef struct _nt_create_process_params {
+ __out void * hprocess;
+ __out void * hthread;
+ __out nt_client_id cid;
+ __out nt_process_basic_information pbi;
+ __in void * himage;
+ __in wchar16_t * image_name;
+ __in wchar16_t * cmd_line;
+ __in wchar16_t * environment;
+ __in nt_runtime_data_block * rtblock;
+ __in uint32_t desired_access_process;
+ __in uint32_t desired_access_thread;
+ __in nt_object_attributes * obj_attr_process;
+ __in nt_object_attributes * obj_attr_thread;
+ __in uint32_t creation_flags_process;
+ __in uint32_t creation_flags_thread;
+ __in nt_process_parameters * process_params;
+ __in_out nt_create_process_info * create_process_info;
+ __in nt_create_process_ext_params * create_process_ext_params;
+ __in_out uintptr_t * buffer;
+ __in size_t buflen;
+} nt_create_process_params;
+
+
+typedef int32_t __stdcall ntapi_zw_create_process(
+ __out void ** hprocess,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __in void * hinherit_from_process,
+ __in unsigned char inherit_handles,
+ __in void * hsection __optional,
+ __in void * hdebug_port __optional,
+ __in void * hexception_port __optional);
+
+
+/* zw_create_user_process: newer OS versions only */
+typedef int32_t __stdcall ntapi_zw_create_user_process(
+ __out void ** hprocess,
+ __out void ** hthread,
+ __in uint32_t desired_access_process,
+ __in uint32_t desired_access_thread,
+ __in nt_object_attributes * obj_attr_process __optional,
+ __in nt_object_attributes * obj_attr_thread __optional,
+ __in uint32_t creation_flags_process,
+ __in uint32_t creation_flags_thread,
+ __in nt_process_parameters * process_params __optional,
+ __in_out nt_create_process_info * create_process_info,
+ __in nt_create_process_ext_params * create_process_ext_params);
+
+
+typedef int32_t __stdcall ntapi_zw_open_process(
+ __out void ** hprocess,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __in nt_client_id * cid __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_terminate_process(
+ __in void * hprocess __optional,
+ __in int32_t status);
+
+
+typedef int32_t __stdcall ntapi_zw_query_information_process(
+ __in void * hprocess,
+ __in nt_process_info_class process_info_class,
+ __out void * process_info,
+ __in size_t process_info_length,
+ __out uint32_t * returned_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_set_information_process(
+ __in void * hprocess,
+ __in nt_process_info_class process_info_class,
+ __in void * process_info,
+ __in uint32_t process_info_length);
+
+
+typedef int32_t __stdcall ntapi_zw_flush_instruction_cache(
+ __in void * hprocess,
+ __in void * base_addr __optional,
+ __in size_t flush_size);
+
+
+typedef int32_t __stdcall ntapi_rtl_create_process_parameters(
+ __out nt_process_parameters ** process_params,
+ __in nt_unicode_string * image_file,
+ __in nt_unicode_string * dll_path __optional,
+ __in nt_unicode_string * current_directory __optional,
+ __in nt_unicode_string * command_line __optional,
+ __in wchar16_t * environment __optional,
+ __in nt_unicode_string * window_title __optional,
+ __in nt_unicode_string * desktop_info __optional,
+ __in nt_unicode_string * shell_info __optional,
+ __in nt_unicode_string * runtime_info __optional);
+
+
+typedef void * __stdcall ntapi_rtl_normalize_process_params(
+ __in nt_process_parameters * process_params);
+
+
+typedef int32_t __stdcall ntapi_rtl_destroy_process_parameters(
+ __in nt_process_parameters * process_params);
+
+
+typedef nt_debug_buffer * __stdcall ntapi_rtl_create_query_debug_buffer(
+ __in size_t size,
+ __in int32_t event_pair);
+
+
+typedef int32_t __stdcall ntapi_rtl_destroy_query_debug_buffer(
+ __in nt_debug_buffer * debug_buffer);
+
+
+typedef int32_t __stdcall ntapi_rtl_query_process_debug_information(
+ __in uintptr_t process_id,
+ __in uint32_t debug_info_class_mask,
+ __in_out nt_debug_buffer * debug_buffer);
+
+
+typedef int32_t __stdcall ntapi_rtl_clone_user_process(
+ __in uint32_t process_flags,
+ __in nt_sd * process_sec_desc __optional,
+ __in nt_sd * thread_sec_desc __optional,
+ __in void * hport_debug __optional,
+ __out nt_user_process_info * process_info);
+
+
+/* extensions */
+typedef intptr_t __fastcall ntapi_tt_fork(
+ __out void ** hprocess,
+ __out void ** hthread);
+
+
+typedef int32_t __stdcall ntapi_tt_create_remote_process_params(
+ __in void * hprocess,
+ __out nt_process_parameters ** rprocess_params,
+ __in nt_unicode_string * image_file,
+ __in nt_unicode_string * dll_path __optional,
+ __in nt_unicode_string * current_directory __optional,
+ __in nt_unicode_string * command_line __optional,
+ __in wchar16_t * environment __optional,
+ __in nt_unicode_string * window_title __optional,
+ __in nt_unicode_string * desktop_info __optional,
+ __in nt_unicode_string * shell_info __optional,
+ __in nt_unicode_string * runtime_data __optional);
+
+
+typedef int32_t __stdcall ntapi_tt_create_native_process(
+ __out nt_create_process_params * params);
+
+
+typedef int32_t __stdcall ntapi_tt_get_runtime_data(
+ __out nt_runtime_data ** pdata,
+ __in wchar16_t ** argv);
+
+typedef int32_t __stdcall ntapi_tt_init_runtime_data(
+ __in_out nt_runtime_data * rtdata);
+
+typedef int32_t __stdcall ntapi_tt_update_runtime_data(
+ __in_out nt_runtime_data * rtdata);
+
+typedef int32_t __stdcall ntapi_tt_exec_map_image_as_data(
+ __in_out nt_executable_image * image);
+
+
+typedef int32_t __stdcall ntapi_tt_exec_unmap_image(
+ __in nt_executable_image * image);
+
+#endif
diff --git a/include/ntapi/nt_profiling.h b/include/ntapi/nt_profiling.h
new file mode 100644
index 0000000..4c11909
--- /dev/null
+++ b/include/ntapi/nt_profiling.h
@@ -0,0 +1,41 @@
+#ifndef _NT_PROFILING_H_
+#define _NT_PROFILING_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+
+typedef enum _nt_kprofile_source {
+ NT_PROFILE_TIME
+} nt_kprofile_source;
+
+
+typedef int32_t __stdcall ntapi_zw_create_profile(
+ __out void ** hprofile,
+ __in void * hprocess,
+ __in void * base,
+ __in size_t size,
+ __in uint32_t bucket_shift,
+ __in uint32_t * buffer,
+ __in size_t buffer_length,
+ __in nt_kprofile_source source,
+ __in uint32_t process_mask);
+
+
+typedef int32_t __stdcall ntapi_zw_set_interval_profile(
+ __in uint32_t interval,
+ __in nt_kprofile_source source);
+
+
+typedef int32_t __stdcall ntapi_zw_query_interval_profile(
+ __in nt_kprofile_source source,
+ __out uint32_t * interval);
+
+
+typedef int32_t __stdcall ntapi_zw_start_profile(
+ __in void * hprofile);
+
+
+typedef int32_t __stdcall ntapi_zw_stop_profile(
+ __in void * hprofile);
+
+#endif
diff --git a/include/ntapi/nt_registry.h b/include/ntapi/nt_registry.h
new file mode 100644
index 0000000..7634d8a
--- /dev/null
+++ b/include/ntapi/nt_registry.h
@@ -0,0 +1,339 @@
+#ifndef _NT_REGISTRY_H_
+#define _NT_REGISTRY_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+
+typedef enum _nt_registry_types {
+ NT_REG_NONE = 0x00,
+ NT_REG_SZ = 0x01,
+ NT_REG_EXPAND_SZ = 0x02,
+ NT_REG_BINARY = 0x03,
+ NT_REG_DWORD = 0x04,
+ NT_REG_DWORD_LITTLE_ENDIAN = 0x04,
+ NT_REG_DWORD_BIG_ENDIAN = 0x05,
+ NT_REG_LINK = 0x06,
+ NT_REG_MULTI_SZ = 0x07,
+ NT_REG_RESOURCE_LIST = 0x08,
+ NT_REG_FULL_RESOURCE_DESCRIPTOR = 0x09,
+ NT_REG_RESOURCE_REQUIREMENTS_LIST = 0x0A,
+ NT_REG_QWORD = 0x0B,
+ NT_REG_QWORD_LITTLE_ENDIAN = 0x0B,
+} nt_registry_types;
+
+
+typedef enum _nt_key_info_class {
+ NT_KEY_BASIC_INFORMATION,
+ NT_KEY_NODE_INFORMATION,
+ NT_KEY_FULL_INFORMATION,
+ NT_KEY_NAME_INFORMATION,
+} nt_key_info_class;
+
+
+typedef enum _nt_key_value_info_class {
+ NT_KEY_VALUE_BASIC_INFORMATION,
+ NT_KEY_VALUE_FULL_INFORMATION,
+ NT_KEY_VALUE_PARTIAL_INFORMATION,
+ NT_KEY_VALUE_FULL_INFORMATION_ALIGN64,
+} nt_key_value_info_class;
+
+
+typedef enum _nt_key_set_info_class {
+ NT_KEY_LAST_WRITE_TIME_INFORMATION = 0
+} nt_key_set_info_class;
+
+
+/* registry key access bits */
+#define NT_KEY_QUERY_VALUE 0x00000001
+#define NT_KEY_SET_VALUE 0x00000002
+#define NT_KEY_CREATE_SUB_NT_KEY 0x00000004
+#define NT_KEY_ENUMERATE_SUB_NT_KEYS 0x00000008
+#define NT_KEY_NOTIFY 0x00000010
+#define NT_KEY_CREATE_LINK 0x00000020
+#define NT_KEY_WOW64_64NT_KEY 0x00000100
+#define NT_KEY_WOW64_32NT_KEY 0x00000200
+#define NT_KEY_WRITE 0x00020006
+#define NT_KEY_READ 0x00020019
+#define NT_KEY_EXECUTE 0x00020019
+#define NT_KEY_ALL_ACCESS 0x000F003F
+
+
+/* registry option bits */
+#define NT_REG_OPTION_NON_VOLATILE 0x00000000L
+#define NT_REG_OPTION_VOLATILE 0x00000001L
+#define NT_REG_OPTION_CREATE_LINK 0x00000002L
+#define NT_REG_OPTION_BACKUP_RESTORE 0x00000004L
+#define NT_REG_OPTION_OPEN_LINK 0x00000008L
+
+
+/* registry hive option bits */
+#define NT_REG_WHOLE_HIVE_VOLATILE 0x00000001L
+#define NT_REG_REFRESH_HIVE 0x00000002L
+#define NT_REG_NO_LAZY_FLUSH 0x00000004L
+#define NT_REG_FORCE_RESTORE 0x00000008L
+
+
+/* registry disposition bits */
+#define NT_REG_CREATED_NEW_KEY 0x00000000L
+#define NT_REG_OPENED_EXISTING_KEY 0x00000001L
+
+
+/* registry monitor bits */
+#define NT_REG_MONITOR_SINGLE_KEY 0x0000
+#define NT_REG_MONITOR_SECOND_KEY 0x0001
+
+
+/* registry key notification bits */
+#define NT_REG_NOTIFY_CHANGE_NAME 0x00000001L
+#define NT_REG_NOTIFY_CHANGE_ATTRIBUTES 0x00000002L
+#define NT_REG_NOTIFY_CHANGE_LAST_SET 0x00000004L
+#define NT_REG_NOTIFY_CHANGE_SECURITY 0x00000008L
+
+#define NT_REG_LEGAL_CHANGE_FILTER NT_REG_NOTIFY_CHANGE_NAME \
+ | NT_REG_NOTIFY_CHANGE_ATTRIBUTES \
+ | NT_REG_NOTIFY_CHANGE_LAST_SET \
+ | NT_REG_NOTIFY_CHANGE_SECURITY
+
+
+typedef struct _nt_key_basic_information {
+ nt_large_integer last_write_time;
+ uint32_t title_index;
+ uint32_t name_length;
+ wchar16_t name[];
+} nt_key_basic_information;
+
+
+typedef struct _nt_key_node_information {
+ nt_large_integer last_write_time;
+ uint32_t title_index;
+ uint32_t class_offset;
+ uint32_t class_length;
+ uint32_t name_length;
+ wchar16_t name[];
+} nt_key_node_information;
+
+
+typedef struct _nt_key_full_information {
+ nt_large_integer last_write_time;
+ uint32_t title_index;
+ uint32_t class_offset;
+ uint32_t class_length;
+ uint32_t sub_keys;
+ uint32_t max_name_len;
+ uint32_t max_class_len;
+ uint32_t values;
+ uint32_t max_value_name_len;
+ uint32_t max_value_data_len;
+ wchar16_t kclass[];
+} nt_key_full_information;
+
+
+typedef struct _nt_key_name_information {
+ uint32_t name_length;
+ wchar16_t name[];
+} nt_key_name_information;
+
+
+typedef struct _nt_key_value_basic_information {
+ uint32_t title_index;
+ uint32_t type;
+ uint32_t name_length;
+ wchar16_t name[];
+} _nt_key_value_basic_information;
+
+
+typedef struct _nt_key_value_full_information {
+ uint32_t title_index;
+ uint32_t type;
+ uint32_t data_offset;
+ uint32_t data_length;
+ uint32_t name_length;
+ wchar16_t name[];
+} nt_key_value_full_information;
+
+
+typedef struct _nt_key_value_partial_information {
+ uint32_t title_index;
+ uint32_t type;
+ uint32_t data_length;
+ unsigned char data[];
+} nt_key_value_partial_information;
+
+
+typedef struct _nt_key_value_entry {
+ nt_unicode_string * value_name;
+ uint32_t data_length;
+ uint32_t data_offset;
+ uint32_t type;
+} nt_key_value_entry;
+
+
+typedef struct _nt_key_last_write_time_information {
+ nt_large_integer last_write_time;
+} nt_key_last_write_time_information;
+
+
+typedef int32_t __stdcall ntapi_zw_create_key(
+ __out void ** hkey,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __in uint32_t title_index,
+ __in nt_unicode_string * reg_class __optional,
+ __in uint32_t create_options,
+ __out uint32_t * disposition __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_open_key(
+ __out void ** hkey,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_delete_key(
+ __in void * hkey);
+
+
+typedef int32_t __stdcall ntapi_zw_flush_key(
+ __in void * hkey);
+
+
+typedef int32_t __stdcall ntapi_zw_save_key(
+ __in void * hkey,
+ __in void * hfile);
+
+
+typedef int32_t __stdcall ntapi_zw_save_merged_keys(
+ __in void * hkey_1st,
+ __in void * hkey_2nd,
+ __in void * hfile);
+
+
+typedef int32_t __stdcall ntapi_zw_restore_key(
+ __in void * hkey,
+ __in void * hfile,
+ __in uint32_t flags);
+
+
+typedef int32_t __stdcall ntapi_zw_load_key(
+ __in nt_object_attributes key_obj_attr,
+ __in nt_object_attributes file_obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_load_key2(
+ __in nt_object_attributes key_obj_attr,
+ __in nt_object_attributes file_obj_attr,
+ __in uint32_t flags);
+
+
+typedef int32_t __stdcall ntapi_zw_unload_key(
+ __in nt_object_attributes key_obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_query_open_sub_keys(
+ __in nt_object_attributes key_obj_attr,
+ __out uint32_t * number_of_keys);
+
+
+typedef int32_t __stdcall ntapi_zw_replace_key(
+ __in nt_object_attributes new_file_obj_attr,
+ __in void * hkey,
+ __in nt_object_attributes old_file_obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_set_information_key(
+ __in void * hkey,
+ __in nt_key_set_info_class key_info_class,
+ __in void * key_info,
+ __in uint32_t key_info_length);
+
+
+typedef int32_t __stdcall ntapi_zw_query_key(
+ __in void * hkey,
+ __in nt_key_info_class key_info_class,
+ __out void * key_info,
+ __in uint32_t key_info_length,
+ __out uint32_t * result_length);
+
+
+typedef int32_t __stdcall ntapi_zw_enumerate_key(
+ __in void * hkey,
+ __in uint32_t index,
+ __in nt_key_info_class key_info_class,
+ __out void * key_info,
+ __in uint32_t key_info_length,
+ __out uint32_t * result_length);
+
+
+typedef int32_t __stdcall ntapi_zw_notify_change_key(
+ __in void * hkey,
+ __in void * hevent __optional,
+ __in nt_io_apc_routine * apc_routine __optional,
+ __in void * apc_context __optional,
+ __out nt_io_status_block * io_status_block,
+ __in uint32_t notify_filter,
+ __in unsigned char watch_subtree,
+ __in void * buffer,
+ __in uint32_t buffer_length,
+ __in unsigned char asynchronous);
+
+
+typedef int32_t __stdcall ntapi_zw_notify_change_multiple_keys(
+ __in void * hkey,
+ __in uint32_t flags,
+ __in nt_object_attributes * key_obj_attr,
+ __in void * hevent __optional,
+ __in nt_io_apc_routine * apc_routine __optional,
+ __in void * apc_context __optional,
+ __out nt_io_status_block * io_status_block,
+ __in uint32_t notify_filter,
+ __in unsigned char watch_subtree,
+ __in void * buffer,
+ __in uint32_t buffer_length,
+ __in unsigned char asynchronous);
+
+
+typedef int32_t __stdcall ntapi_zw_delete_value_key(
+ __in void * hkey,
+ __in nt_unicode_string * value_name);
+
+
+typedef int32_t __stdcall ntapi_zw_set_value_key(
+ __in void * hkey,
+ __in nt_unicode_string * value_name,
+ __in uint32_t title_index,
+ __in uint32_t type,
+ __in void * data,
+ __in uint32_t data_size);
+
+
+typedef int32_t __stdcall ntapi_zw_query_value_key(
+ __in void * hkey,
+ __in nt_unicode_string * value_name,
+ __in nt_key_value_info_class key_value_info_class,
+ __out void * key_value_info,
+ __in uint32_t key_value_info_length,
+ __out uint32_t * result_length);
+
+
+typedef int32_t __stdcall ntapi_zw_enumerate_value_key(
+ __in void * hkey,
+ __in uint32_t index,
+ __in nt_key_value_info_class key_value_info_class,
+ __out void * key_value_info,
+ __in uint32_t key_value_info_length,
+ __out uint32_t * result_length);
+
+
+typedef int32_t __stdcall ntapi_zw_query_multiple_value_key(
+ __in void * hkey,
+ __in_out nt_key_value_entry * value_list,
+ __in uint32_t number_of_values,
+ __out void * buffer,
+ __in_out uint32_t * buffer_length,
+ __out uint32_t * buffer_nedded);
+
+
+typedef int32_t __stdcall ntapi_zw_initialize_registry(
+ __in unsigned char setup);
+
+#endif
diff --git a/include/ntapi/nt_section.h b/include/ntapi/nt_section.h
new file mode 100644
index 0000000..f1ce381
--- /dev/null
+++ b/include/ntapi/nt_section.h
@@ -0,0 +1,137 @@
+#ifndef _NT_SECTION_H_
+#define _NT_SECTION_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+#include "nt_memory.h"
+
+typedef enum _nt_section_info_class {
+ NT_SECTION_BASIC_INFORMATION,
+ NT_SECTION_IMAGE_INFORMATION
+} nt_section_info_class;
+
+
+typedef enum _nt_section_inherit {
+ NT_VIEW_SHARE = 1,
+ NT_VIEW_UNMAP = 2
+} nt_section_inherit;
+
+/* section attributes */
+#define NT_SEC_BASED 0x00200000
+#define NT_SEC_NO_CHANGE 0x00400000
+#define NT_SEC_FILE 0x00800000
+#define NT_SEC_IMAGE 0x01000000
+#define NT_SEC_VLM 0x02000000
+#define NT_SEC_RESERVE 0x04000000
+#define NT_SEC_COMMIT 0x08000000
+#define NT_SEC_NOCACHE 0x10000000
+#define NT_SEC_IMAGE_NO_EXECUTE 0x11000000
+#define NT_SEC_LARGE_PAGES 0x80000000
+#define NT_SEC_WRITECOMBINE 0x40000000
+
+/* section memory allocation attributes */
+#define NT_SEC_AT_EXTENDABLE_FILE 0x00002000 /* view may exceed section size */
+#define NT_SEC_AT_RESERVED 0x20000000 /* ignored */
+#define NT_SEC_AT_ROUND_TO_PAGE 0x40000000 /* adjust address and/or size as necessary */
+
+
+/* section access bits */
+#define NT_SECTION_QUERY 0x00000001
+#define NT_SECTION_MAP_WRITE 0x00000002
+#define NT_SECTION_MAP_READ 0x00000004
+#define NT_SECTION_MAP_EXECUTE 0x00000008
+#define NT_SECTION_EXTEND_SIZE 0x00000010
+#define NT_SECTION_MAP_EXECUTE_EXPLICIT 0x00000020
+#define NT_STANDARD_RIGHTS_REQUIRED 0x000F0000
+#define NT_SECTION_ALL_ACCESS NT_STANDARD_RIGHTS_REQUIRED \
+ | NT_SECTION_QUERY \
+ | NT_SECTION_MAP_WRITE \
+ | NT_SECTION_MAP_READ \
+ | NT_SECTION_MAP_EXECUTE \
+ | NT_SECTION_EXTEND_SIZE
+
+
+typedef struct _nt_section_basic_information {
+ void * base_address;
+ uint32_t section_attr;
+ nt_large_integer section_size;
+} nt_section_basic_information, nt_sbi;
+
+typedef struct _nt_section_image_information {
+ void * entry_point;
+ uint32_t stack_zero_bits;
+ size_t stack_reserve;
+ size_t stack_commit;
+ uint32_t subsystem;
+ uint16_t subsystem_minor_version;
+ uint16_t subsystem_major_version;
+ uint32_t unknown;
+ uint32_t characteristics;
+ uint16_t image_number;
+ unsigned char executable;
+ unsigned char image_flags;
+ uint32_t loader_flags;
+ uint32_t image_file_size;
+ uint32_t image_checksum;
+} nt_section_image_information, nt_sec_img_inf;
+
+
+typedef int32_t __stdcall ntapi_zw_create_section(
+ __out void ** hsection,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __in nt_large_integer * section_size __optional,
+ __in uint32_t section_protect,
+ __in uint32_t section_attr,
+ __in void * hfile);
+
+typedef int32_t __stdcall ntapi_zw_open_section(
+ __out void ** hsection,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_query_section(
+ __in void * hsection,
+ __in nt_section_info_class sec_info_class,
+ __out void * sec_info,
+ __in size_t sec_info_length,
+ __out size_t * returned_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_extend_section(
+ __in void * hsection,
+ __in nt_large_integer * section_size);
+
+
+typedef int32_t __stdcall ntapi_zw_map_view_of_section(
+ __in void * hsection,
+ __in void * hprocess,
+ __in_out void ** base_address,
+ __in uint32_t zero_bits,
+ __in size_t commit_size,
+ __in_out nt_large_integer * section_offset __optional,
+ __in_out size_t * view_size,
+ __in nt_section_inherit section_inherit_disposition,
+ __in uint32_t allocation_type,
+ __in uint32_t protect);
+
+
+
+typedef int32_t __stdcall ntapi_zw_unmap_view_of_section(
+ __in void * hprocess,
+ __in void * base_address);
+
+
+typedef int32_t __stdcall ntapi_zw_are_mapped_files_the_same(
+ __in void * addr_1st,
+ __in void * addr_2nd);
+
+
+/* extensions */
+typedef int32_t __stdcall ntapi_tt_get_section_name(
+ __in void * addr,
+ __out nt_mem_sec_name * buffer,
+ __in uint32_t buffer_size);
+
+#endif
diff --git a/include/ntapi/nt_security.h b/include/ntapi/nt_security.h
new file mode 100644
index 0000000..20fa956
--- /dev/null
+++ b/include/ntapi/nt_security.h
@@ -0,0 +1,190 @@
+#ifndef _NT_SECURITY_H_
+#define _NT_SECURITY_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+
+typedef enum _nt_audit_event_type {
+ NT_AUDIT_EVENT_OBJECT_ACCESS,
+ NT_AUDIT_EVENT_DIRECTORY_SERVICE_ACCESS
+} nt_audit_event_type;
+
+
+/* audit flag bits */
+#define NT_AUDIT_ALLOW_NO_PRIVILEGE 0x01
+
+
+typedef struct _nt_privilege_set {
+ uint32_t privilege_count;
+ uint32_t control;
+ nt_luid_and_attributes privilege[];
+} nt_privilege_set;
+
+
+typedef struct _nt_object_type_list {
+ int32_t level;
+ int32_t sbz;
+ nt_guid * object_type;
+} nt_object_type_list;
+
+
+typedef int32_t __stdcall ntapi_zw_privilege_check(
+ __in void * htoken,
+ __in nt_privilege_set * required_privileges,
+ __out unsigned char * result);
+
+
+typedef int32_t __stdcall ntapi_zw_privilege_object_audit_alarm(
+ __in nt_unicode_string * subsystem_name,
+ __in void * handle_id,
+ __in void * htoken,
+ __in uint32_t desired_access,
+ __in nt_privilege_set * privileges,
+ __in unsigned char access_granted);
+
+
+typedef int32_t __stdcall ntapi_zw_privileged_service_audit_alarm(
+ __in nt_unicode_string * subsystem_name,
+ __in nt_unicode_string * service_name,
+ __in void * htoken,
+ __in nt_privilege_set * privileges,
+ __in unsigned char access_granted);
+
+
+typedef int32_t __stdcall ntapi_zw_access_check(
+ __in nt_security_descriptor * sec_desc,
+ __in void * htoken,
+ __in uint32_t desired_access,
+ __in nt_generic_mapping * generic_mapping,
+ __in nt_privilege_set * privilege_set,
+ __in uint32_t * privilege_set_length,
+ __out uint32_t * granted_access,
+ __out unsigned char * access_status);
+
+
+typedef int32_t __stdcall ntapi_zw_access_check_and_audit_alarm(
+ __in nt_unicode_string * subsystem_name,
+ __in void * handle_id,
+ __in nt_unicode_string * object_type_name,
+ __in nt_unicode_string * object_name,
+ __in nt_security_descriptor * sec_desc,
+ __in uint32_t desired_access,
+ __in nt_generic_mapping * generic_mapping,
+ __in unsigned char object_creation,
+ __out uint32_t * granted_access,
+ __out unsigned char * access_status,
+ __out unsigned char * generate_on_close);
+
+
+typedef int32_t __stdcall ntapi_zw_access_check_by_type(
+ __in nt_security_descriptor * sec_desc,
+ __in nt_sid * principal_self_sid,
+ __in void * htoken,
+ __in uint32_t desired_access,
+ __in nt_object_type_list * obj_type_list,
+ __in uint32_t obj_type_list_length,
+ __in nt_generic_mapping * generic_mapping,
+ __in nt_privilege_set * privilege_set,
+ __in uint32_t * privilege_set_length,
+ __out uint32_t * granted_access,
+ __out unsigned char * access_status);
+
+
+typedef int32_t __stdcall ntapi_zw_access_check_by_type_and_audit_alarm(
+ __in nt_unicode_string * subsystem_name,
+ __in void * handle_id,
+ __in nt_unicode_string * object_type_name,
+ __in nt_unicode_string * object_name,
+ __in nt_security_descriptor * sec_desc,
+ __in nt_sid * principal_self_sid,
+ __in uint32_t desired_access,
+ __in nt_audit_event_type audit_type,
+ __in uint32_t augid_flags,
+ __in nt_object_type_list * obj_type_list,
+ __in uint32_t obj_type_list_length,
+ __in nt_generic_mapping * generic_mapping,
+ __in unsigned char object_creation,
+ __out uint32_t * granted_access,
+ __out uint32_t * access_status,
+ __out unsigned char * generate_on_close);
+
+
+typedef int32_t __stdcall ntapi_zw_access_check_by_type_result_list(
+ __in nt_security_descriptor * sec_desc,
+ __in nt_sid * principal_self_sid,
+ __in void * htoken,
+ __in uint32_t desired_access,
+ __in nt_object_type_list * obj_type_list,
+ __in uint32_t obj_type_list_length,
+ __in nt_generic_mapping * generic_mapping,
+ __in nt_privilege_set * privilege_set,
+ __in uint32_t * privilege_set_length,
+ __out uint32_t * granted_access_list,
+ __out uint32_t * access_status_list);
+
+
+typedef int32_t __stdcall ntapi_zw_access_check_by_type_result_list_and_audit_alarm(
+ __in nt_unicode_string * subsystem_name,
+ __in void * handle_id,
+ __in nt_unicode_string * object_type_name,
+ __in nt_unicode_string * object_name,
+ __in nt_security_descriptor * sec_desc,
+ __in nt_sid * principal_self_sid,
+ __in uint32_t desired_access,
+ __in nt_audit_event_type audit_type,
+ __in uint32_t augid_flags,
+ __in nt_object_type_list * obj_type_list,
+ __in uint32_t obj_type_list_length,
+ __in nt_generic_mapping * generic_mapping,
+ __in unsigned char object_creation,
+ __out uint32_t * granted_access_list,
+ __out uint32_t * access_status_list,
+ __out uint32_t * generate_on_close);
+
+
+typedef int32_t __stdcall ntapi_zw_access_check_by_type_result_list_and_audit_alarm_by_handle(
+ __in nt_unicode_string * subsystem_name,
+ __in void * handle_id,
+ __in void * htoken,
+ __in nt_unicode_string * object_type_name,
+ __in nt_unicode_string * object_name,
+ __in nt_security_descriptor * sec_desc,
+ __in nt_sid * principal_self_sid,
+ __in uint32_t desired_access,
+ __in nt_audit_event_type audit_type,
+ __in uint32_t augid_flags,
+ __in nt_object_type_list * obj_type_list,
+ __in uint32_t obj_type_list_length,
+ __in nt_generic_mapping * generic_mapping,
+ __in unsigned char object_creation,
+ __out uint32_t * granted_access_list,
+ __out uint32_t * access_status_list,
+ __out uint32_t * generate_on_close);
+
+
+typedef int32_t __stdcall ntapi_zw_open_object_audit_alarm(
+ __in nt_unicode_string * subsystem_name,
+ __in void ** handle_id,
+ __in nt_unicode_string * object_type_name,
+ __in nt_unicode_string * object_name,
+ __in nt_security_descriptor * sec_desc,
+ __in void * htoken,
+ __in uint32_t desired_access,
+ __in uint32_t granted_access,
+ __in nt_privilege_set * privileges __optional,
+ __in unsigned char object_creation,
+ __in unsigned char access_granted,
+ __out unsigned char * generate_on_close);
+
+typedef int32_t __stdcall ntapi_zw_close_object_audit_alarm(
+ __in nt_unicode_string * subsystem_name,
+ __in void * handle_id,
+ __out unsigned char * generate_on_close);
+
+
+typedef int32_t __stdcall ntapi_zw_delete_object_audit_alarm(
+ __in nt_unicode_string * subsystem_name,
+ __in void * handle_id,
+ __out unsigned char * generate_on_close);
+
+#endif
diff --git a/include/ntapi/nt_slist.h b/include/ntapi/nt_slist.h
new file mode 100644
index 0000000..edb5a0f
--- /dev/null
+++ b/include/ntapi/nt_slist.h
@@ -0,0 +1,22 @@
+#ifndef _NT_SLIST_H_
+#define _NT_SLIST_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_sync.h"
+
+struct nt_slist;
+struct nt_slist_node;
+
+struct nt_slist_node {
+ struct nt_slist_node * next;
+ uintptr_t data;
+};
+
+struct __attr_aligned__(NT_SYNC_BLOCK_SIZE) nt_slist {
+ struct nt_slist_node * head;
+ intptr_t nitems;
+ intptr_t busy;
+ intptr_t padding[NT_SYNC_BLOCK_SIZE/sizeof(size_t)-3];
+};
+
+#endif
diff --git a/include/ntapi/nt_socket.h b/include/ntapi/nt_socket.h
new file mode 100644
index 0000000..7e08697
--- /dev/null
+++ b/include/ntapi/nt_socket.h
@@ -0,0 +1,429 @@
+#ifndef _NT_SOCKET_H_
+#define _NT_SOCKET_H_
+
+/**
+ * socket api:
+ * -----------
+ * here we provide native libraries and applications
+ * with a minimal socket abstraction layer;
+ * if you are interested in posix socket semantics
+ * then this header is REALLY NOT what you
+ * are looking for, as the most portable scenario
+ * (psxscl+libc) neither requires nor allows for
+ * direct interaction with the below interfaces.
+ *
+ * (additional information for the yet curious...)
+ *
+ * client libraries and applications are responsible
+ * for the entire bookkeeping, which should be
+ * easy using the nt_socket structure.
+ *
+ * kernel sockets are created using ZwCreateFile,
+ * and are then manipulated (bind, connect, send,
+ * recv, listen, accept, getsockname, etc.) using
+ * ZwDeviceIoControlFile. accordingly, the main
+ * objective of the below interfaces is to provide
+ * thin wrappers around the above NT system calls,
+ * thereby releasing you from the tedious task
+ * of formatting control messages according to
+ * individual IOCTL codes, protocol types, or
+ * different versions of the operating system.
+ *
+ * another noteworthy objective is the direct
+ * translation between posix socket semantics on the
+ * one hand, and the interfaces that this module
+ * provides on the other. functions in this module
+ * normally take the same arguments as their
+ * posix equivalents, yet require a pointer
+ * to an nt_socket structure in place of an integer
+ * file descriptor (in the posix library, the task
+ * of converting an integer file descriptor to the
+ * above pointer is a trivial one). for functions
+ * such as send() and recv(), the return value is
+ * the system's native NTSTATUS; the number of bytes
+ * sent or received is then returned in a separate
+ * argument, and can also be obtained, along with
+ * extended status, from the info member of the iosb
+ * argument. last but not least, each function in
+ * this module accepts one or more optional arguments
+ * of questionable relevance:-)
+**/
+
+#include <psxtypes/psxtypes.h>
+#include "nt_status.h"
+#include "nt_object.h"
+#include "nt_tty.h"
+
+/* afd socket domains */
+#define NT_AF_UNSPEC (0x0000u)
+#define NT_AF_UNIX (0x0001u)
+#define NT_AF_INET (0x0002u)
+#define NT_AF_IMPLINK (0x0003u)
+#define NT_AF_PUP (0x0004u)
+#define NT_AF_CHAOS (0x0005u)
+#define NT_AF_NS (0x0006u)
+#define NT_AF_IPX (0x0006u) /* synonym */
+#define NT_AF_ISO (0x0007u)
+#define NT_AF_OSI (0x0007u) /* synonym */
+#define NT_AF_ECMA (0x0008u)
+#define NT_AF_DATAKIT (0x0009u)
+#define NT_AF_CCITT (0x000Au)
+#define NT_AF_SNA (0x000Bu)
+#define NT_AF_DECnet (0x000Cu)
+#define NT_AF_DLI (0x000Du)
+#define NT_AF_LAT (0x000Eu)
+#define NT_AF_HYLINK (0x000Fu)
+#define NT_AF_APPLETALK (0x0010u)
+#define NT_AF_NETBIOS (0x0011u)
+#define NT_AF_VOICEVIEW (0x0012u)
+#define NT_AF_FIREFOX (0x0013u)
+#define NT_AF_UNKNOWN_1ST (0x0014u)
+#define NT_AF_BAN (0x0015u)
+#define NT_AF_ATM (0x0016u)
+#define NT_AF_INET6 (0x0017u)
+#define NT_AF_CLUSTER (0x0018u)
+#define NT_AF_12844 (0x0019u)
+#define NT_AF_IRDA (0x001Au)
+#define NT_AF_NETDES (0x001Cu)
+#define NT_AF_TCNPROCESS (0x001Du)
+#define NT_AF_TCNMESSAGE (0x001Eu)
+#define NT_AF_ICLFXBM (0x001Fu)
+#define NT_AF_BTH (0x0020u)
+#define NT_AF_LINK (0x0021u)
+
+
+/* afd socket types */
+#define NT_SOCK_STREAM (0x0001u)
+#define NT_SOCK_DGRAM (0x0002u)
+#define NT_SOCK_RAW (0x0003u)
+#define NT_SOCK_RDM (0x0004u)
+#define NT_SOCK_SEQPACKET (0x0005u)
+
+
+/* afd socket protocols */
+#define NT_IPPROTO_IP 0
+#define NT_IPPROTO_HOPOPTS 0
+#define NT_IPPROTO_ICMP 1
+#define NT_IPPROTO_IGMP 2
+#define NT_IPPROTO_GGP 3
+#define NT_IPPROTO_IPV4 4
+#define NT_IPPROTO_ST 5
+#define NT_IPPROTO_TCP 6
+#define NT_IPPROTO_CBT 7
+#define NT_IPPROTO_EGP 8
+#define NT_IPPROTO_IGP 9
+#define NT_IPPROTO_PUP 12
+#define NT_IPPROTO_UDP 17
+#define NT_IPPROTO_IDP 22
+#define NT_IPPROTO_RDP 27
+#define NT_IPPROTO_IPV6 41
+#define NT_IPPROTO_ROUTING 43
+#define NT_IPPROTO_FRAGMENT 44
+#define NT_IPPROTO_ESP 50
+#define NT_IPPROTO_AH 51
+#define NT_IPPROTO_ICMPV6 58
+#define NT_IPPROTO_NONE 59
+#define NT_IPPROTO_DSTOPTS 60
+#define NT_IPPROTO_ND 77
+#define NT_IPPROTO_ICLFXBM 78
+#define NT_IPPROTO_PIM 103
+#define NT_IPPROTO_PGM 113
+#define NT_IPPROTO_L2TP 115
+#define NT_IPPROTO_SCTP 132
+#define NT_IPPROTO_RAW 255
+#define NT_IPPROTO_MAX 256
+#define NT_IPPROTO_RESERVED_RAW 257
+#define NT_IPPROTO_RESERVED_IPSEC 258
+#define NT_IPPROTO_RESERVED_IPSECOFFLOAD 259
+#define NT_IPPROTO_RESERVED_WNV 260
+#define NT_IPPROTO_RESERVED_MAX 261
+
+
+
+/* tdi receive modes */
+#define NT_TDI_RECEIVE_BROADCAST (0x0004u)
+#define NT_TDI_RECEIVE_MULTICAST (0x0008u)
+#define NT_TDI_RECEIVE_PARTIAL (0x0010u)
+#define NT_TDI_RECEIVE_NORMAL (0x0020u)
+#define NT_TDI_RECEIVE_EXPEDITED (0x0040u)
+#define NT_TDI_RECEIVE_PEEK (0x0080u)
+#define NT_TDI_RECEIVE_NO_RESPONSE_EXP (0x0100u)
+#define NT_TDI_RECEIVE_COPY_LOOKAHEAD (0x0200u)
+#define NT_TDI_RECEIVE_ENTIRE_MESSAGE (0x0400u)
+#define NT_TDI_RECEIVE_AT_DISPATCH_LEVEL (0x0800u)
+#define NT_TDI_RECEIVE_CONTROL_INFO (0x1000u)
+#define NT_TDI_RECEIVE_FORCE_INDICATION (0x2000u)
+#define NT_TDI_RECEIVE_NO_PUSH (0x4000u)
+
+/* tdi send modes */
+#define NT_TDI_SEND_EXPEDITED (0x0020u)
+#define NT_TDI_SEND_PARTIAL (0x0040u)
+#define NT_TDI_SEND_NO_RESPONSE_EXPECTED (0x0080u)
+#define NT_TDI_SEND_NON_BLOCKING (0x0100u)
+#define NT_TDI_SEND_AND_DISCONNECT (0x0200u)
+
+/* tdi listen modes */
+#define NT_TDI_QUERY_ACCEPT (0x0001u)
+
+/* tdi disconnect modes */
+#define NT_TDI_DISCONNECT_WAIT (0x0001u)
+#define NT_TDI_DISCONNECT_ABORT (0x0002u)
+#define NT_TDI_DISCONNECT_RELEASE (0x0004u)
+
+/* afd ioctl codes */
+#define NT_AFD_IOCTL_BIND (0x12003u)
+#define NT_AFD_IOCTL_CONNECT (0x12007u)
+#define NT_AFD_IOCTL_LISTEN (0x1200Bu)
+#define NT_AFD_IOCTL_ACCEPT (0x1200Cu)
+#define NT_AFD_IOCTL_DUPLICATE (0x12010u)
+#define NT_AFD_IOCTL_SEND (0x1201Fu)
+#define NT_AFD_IOCTL_UDP_SEND (0x12023u)
+#define NT_AFD_IOCTL_RECV (0x12017u)
+#define NT_AFD_IOCTL_DISCONNECT (0x1202Bu)
+#define NT_AFD_IOCTL_SELECT (0x12024u)
+#define NT_AFD_IOCTL_GET_SOCK_NAME (0x1202Fu)
+#define NT_AFD_IOCTL_GET_PEER_NAME (0x1202Fu)
+#define NT_AFD_IOCTL_SET_CONTEXT (0x1202Fu)
+
+/* afd socket shutdown bits */
+#define NT_AFD_DISCONNECT_WR (0x01u)
+#define NT_AFD_DISCONNECT_RD (0x02u)
+
+/* socket portable shutdown options */
+#define NT_SHUT_RD (0x00u)
+#define NT_SHUT_WR (0x01u)
+#define NT_SHUT_RDWR (0x02u)
+
+/* send, sendto, sendmsg: *nix flags and bit place-holders */
+#define NT_MSG_OOB (0x00000001u)
+#define NT_MSG_PEEK (0x00000002u)
+#define NT_MSG_DONTROUTE (0x00000004u)
+#define NT_MSG_CTRUNC (0x00000008u)
+#define NT_MSG_PROXY (0x00000010u)
+#define NT_MSG_TRUNC (0x00000020u)
+#define NT_MSG_DONTWAIT (0x00000040u)
+#define NT_MSG_EOR (0x00000080u)
+#define NT_MSG_WAITALL (0x00000100u)
+#define NT_MSG_FIN (0x00000200u)
+#define NT_MSG_SYN (0x00000400u)
+#define NT_MSG_CONFIRM (0x00000800u)
+#define NT_MSG_RST (0x00001000u)
+#define NT_MSG_ERRQUEUE (0x00002000u)
+#define NT_MSG_NOSIGNAL (0x00004000u)
+#define NT_MSG_MORE (0x00008000u)
+#define NT_MSG_WAITFORONE (0x00010000u)
+#define NT_MSG_CMSG_CLOEXEC (0x40000000u)
+
+
+/* socket structures */
+typedef struct _nt_socket {
+ union {
+ void * hsocket;
+ void * hfile;
+ void * hpipe;
+ nt_pty * hpty;
+ };
+
+ void * hevent;
+ int32_t refcnt; /* reserved for client */
+ uint16_t fdtype; /* reserved for client */
+ uint16_t sctype; /* reserved for client */
+ uint32_t ctxid; /* reserved for client */
+ uint32_t reserved; /* reserved for client */
+ uint32_t psxflags; /* reserved for client */
+ uint32_t ntflags; /* sc_wait alert flags */
+ nt_large_integer timeout;
+ int32_t iostatus;
+ int32_t waitstatus;
+
+ union {
+ struct {
+ uint16_t domain;
+ uint16_t type;
+ uint32_t protocol;
+ };
+
+ void * vfd;
+ void * vmount;
+ void * hpair;
+ void * dirctx;
+ };
+} nt_socket;
+
+
+typedef struct _nt_scope_id{
+ union {
+ struct {
+ uint32_t zone : 28;
+ uint32_t level : 4;
+ };
+
+ uint32_t value;
+ };
+} nt_scope_id;
+
+
+typedef struct _nt_sockaddr_in4 {
+ uint16_t sa_family;
+ char sa_data[14];
+} nt_sockaddr_in4;
+
+
+typedef struct _nt_sockaddr_in6 {
+ uint16_t sa_family;
+ uint16_t sa_port;
+ uint32_t sa_flow;
+ unsigned char sa_data[16];
+ nt_scope_id sa_scope;
+} nt_sockaddr_in6;
+
+
+typedef union _nt_sockaddr {
+ nt_sockaddr_in4 sa_addr_in4;
+ nt_sockaddr_in6 sa_addr_in6;
+} nt_sockaddr;
+
+
+typedef struct _nt_afd_buffer {
+ size_t length;
+ char * buffer;
+} nt_afd_buffer;
+
+
+typedef struct _nt_afd_listen_info {
+ void * unknown_1st;
+ uint32_t backlog;
+ void * unknown_2nd;
+} nt_afd_listen_info;
+
+
+typedef struct _nt_afd_accept_info {
+ uint32_t sequence;
+ nt_sockaddr addr;
+ uint32_t legacy[2];
+} nt_afd_accept_info;
+
+
+typedef struct _nt_afd_duplicate_info {
+ uint32_t unknown;
+ uint32_t sequence;
+ void * hsocket_dedicated;
+} nt_afd_duplicate_info;
+
+
+typedef struct _nt_afd_send_info {
+ nt_afd_buffer * afd_buffer_array;
+ uint32_t buffer_count;
+ uint32_t afd_flags;
+ uint32_t tdi_flags;
+} nt_afd_send_info;
+
+
+typedef struct _nt_afd_recv_info {
+ nt_afd_buffer * afd_buffer_array;
+ uint32_t buffer_count;
+ uint32_t afd_flags;
+ uint32_t tdi_flags;
+} nt_afd_recv_info;
+
+
+typedef struct _nt_afd_disconnect_info {
+ uint32_t shutdown_flags;
+ uint32_t unknown[3];
+} nt_afd_disconnect_info;
+
+
+/* socket functions */
+typedef int32_t __cdecl ntapi_sc_socket(
+ __out nt_socket * hssocket,
+ __in uint16_t domain,
+ __in uint16_t type,
+ __in uint32_t protocol,
+ __in uint32_t desired_access __optional,
+ __in nt_sqos * sqos __optional,
+ __out nt_io_status_block * iosb __optional);
+
+
+typedef int32_t __cdecl ntapi_sc_bind(
+ __in nt_socket * hssocket,
+ __in const nt_sockaddr * addr,
+ __in uintptr_t addrlen,
+ __in uintptr_t service_flags __optional,
+ __out nt_sockaddr * sockaddr __optional,
+ __out nt_io_status_block * iosb __optional);
+
+
+typedef int32_t __cdecl ntapi_sc_listen(
+ __in nt_socket * hssocket,
+ __in uintptr_t backlog,
+ __out nt_io_status_block * iosb __optional);
+
+
+typedef int32_t __cdecl ntapi_sc_accept(
+ __in nt_socket * hssock_listen,
+ __in nt_sockaddr * addr,
+ __in uint16_t * addrlen,
+ __out nt_socket * hssock_dedicated,
+ __in uintptr_t afdflags __optional,
+ __in uintptr_t tdiflags __optional,
+ __out nt_io_status_block * iosb __optional);
+
+
+typedef int32_t __cdecl ntapi_sc_connect(
+ __in nt_socket * hssocket,
+ __in nt_sockaddr * addr,
+ __in uintptr_t addrlen,
+ __in uintptr_t service_flags __optional,
+ __out nt_io_status_block * iosb __optional);
+
+
+typedef int32_t __cdecl ntapi_sc_send(
+ __in nt_socket * hssocket,
+ __in const void * buffer,
+ __in size_t len,
+ __out ssize_t * bytes_sent __optional,
+ __in uintptr_t afdflags __optional,
+ __in uintptr_t tdiflags __optional,
+ __out nt_io_status_block * iosb __optional);
+
+
+typedef int32_t __cdecl ntapi_sc_recv(
+ __in nt_socket * hssocket,
+ __in const void * buffer,
+ __in size_t len,
+ __out ssize_t * bytes_received __optional,
+ __in uintptr_t afdflags __optional,
+ __in uintptr_t tdiflags __optional,
+ __out nt_io_status_block * iosb __optional);
+
+
+typedef int32_t __cdecl ntapi_sc_shutdown(
+ __in nt_socket * hssocket,
+ __in uintptr_t psxhow,
+ __in uintptr_t afdhow,
+ __out nt_io_status_block * iosb __optional);
+
+
+typedef int32_t __cdecl ntapi_sc_getsockname(
+ __in nt_socket * hssocket,
+ __in nt_sockaddr * addr,
+ __in uint16_t * addrlen,
+ __out nt_io_status_block * iosb __optional);
+
+
+typedef int32_t __cdecl ntapi_sc_server_accept_connection(
+ __in nt_socket * hssocket,
+ __out nt_afd_accept_info * accept_info,
+ __out nt_io_status_block * iosb __optional);
+
+
+typedef int32_t __cdecl ntapi_sc_server_duplicate_socket(
+ __in nt_socket * hssock_listen,
+ __in nt_socket * hssock_dedicated,
+ __in nt_afd_accept_info * accept_info,
+ __out nt_io_status_block * iosb __optional);
+
+
+typedef int32_t __cdecl ntapi_sc_wait(nt_socket * hssocket, nt_iosb * iosb, nt_timeout * timeout);
+
+#endif
diff --git a/include/ntapi/nt_stat.h b/include/ntapi/nt_stat.h
new file mode 100644
index 0000000..2bcac79
--- /dev/null
+++ b/include/ntapi/nt_stat.h
@@ -0,0 +1,46 @@
+#ifndef _NT_STAT_H_
+#define _NT_STAT_H_
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+
+/* ntapi_tt_stat info flags bits */
+#define NT_STAT_DEFAULT (0x00000000)
+#define NT_STAT_COMMON (0x00000001)
+#define NT_STAT_DEV_NAME_COPY (0x00000002)
+#define NT_STAT_NEW_HANDLE (0x80000000)
+
+typedef struct _nt_stat {
+ nt_fbi fbi;
+ nt_fsi fsi;
+ nt_fii fii;
+ nt_fei fei;
+ nt_facci facci;
+ nt_fpi fpi;
+ nt_fmi fmi;
+ nt_falii falii;
+ nt_fssi fssi;
+ void * hfile;
+ uint32_t flags_in;
+ uint32_t flags_out;
+ uint32_t file_name_length;
+ uint32_t file_name_hash;
+ uint32_t dev_name_hash;
+ uint16_t dev_name_strlen;
+ uint16_t dev_name_maxlen;
+ wchar16_t dev_name[];
+} nt_stat;
+
+
+typedef int32_t __stdcall ntapi_tt_stat(
+ __in void * hfile __optional,
+ __in void * hroot __optional,
+ __in nt_unicode_string * path __optional,
+ __out nt_stat * stat,
+ __out uintptr_t * buffer,
+ __in uint32_t buffer_size,
+ __in uint32_t open_options,
+ __in uint32_t flags);
+
+#endif
diff --git a/include/ntapi/nt_statfs.h b/include/ntapi/nt_statfs.h
new file mode 100644
index 0000000..c2aa6d6
--- /dev/null
+++ b/include/ntapi/nt_statfs.h
@@ -0,0 +1,68 @@
+#ifndef _NT_STATFS_H_
+#define _NT_STATFS_H_
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+
+/* ntapi_tt_statfs info flags bits */
+#define NT_STATFS_DEFAULT (0x00000000)
+#define NT_STATFS_COMMON (0x00000001)
+#define NT_STATFS_DEV_NAME_COPY (0x00000002)
+#define NT_STATFS_VOLUME_GUID (0x00000004)
+#define NT_STATFS_DOS_DRIVE_LETTER NT_STATFS_VOLUME_GUID
+#define NT_STATFS_NEW_HANDLE (0x80000000)
+
+
+#define NT_FS_TYPE_FAT16_NAME_HASH (0x00000000)
+#define NT_FS_TYPE_FAT32_NAME_HASH (0x00000001)
+#define NT_FS_TYPE_HPFS_NAME_HASH (0x00000002)
+#define NT_FS_TYPE_MSDOS_NAME_HASH (0x00000003)
+#define NT_FS_TYPE_NTFS_NAME_HASH (0xbfbc5fdb)
+#define NT_FS_TYPE_SMB_NAME_HASH (0x00000004)
+#define NT_FS_TYPE_UDF_NAME_HASH (0x00000005)
+
+typedef struct _nt_fsid_t {
+ uint32_t __val[2];
+} nt_fsid_t;
+
+typedef struct _nt_statfs {
+ uintptr_t f_type;
+ uintptr_t f_bsize;
+ uint64_t f_blocks;
+ uint64_t f_bfree;
+ uint64_t f_bavail;
+ uint64_t f_files;
+ uint64_t f_ffree;
+ nt_fsid_t f_fsid;
+ uintptr_t f_namelen;
+ uintptr_t f_frsize;
+ uintptr_t f_flags;
+ uintptr_t f_spare[4];
+ uint32_t nt_fstype_hash;
+ uint32_t nt_attr;
+ uint32_t nt_control_flags;
+ wchar16_t nt_drive_letter;
+ wchar16_t nt_padding;
+ nt_guid nt_volume_guid;
+ void * hfile;
+ uint32_t flags_in;
+ uint32_t flags_out;
+ uint16_t record_name_strlen;
+ uint16_t dev_name_strlen;
+ uint16_t dev_name_maxlen;
+ uint32_t dev_name_hash;
+ wchar16_t dev_name[];
+} nt_statfs;
+
+
+typedef int32_t __stdcall ntapi_tt_statfs(
+ __in void * hfile __optional,
+ __in void * hroot __optional,
+ __in nt_unicode_string * path __optional,
+ __out nt_statfs * statfs,
+ __out uintptr_t * buffer,
+ __in uint32_t buffer_size,
+ __in uint32_t flags);
+
+
+#endif
diff --git a/include/ntapi/nt_status.h b/include/ntapi/nt_status.h
new file mode 100644
index 0000000..a3d7528
--- /dev/null
+++ b/include/ntapi/nt_status.h
@@ -0,0 +1,1796 @@
+#ifndef _NT_STATUS_H_
+#define _NT_STATUS_H_
+
+#include <psxtypes/psxtypes.h>
+
+typedef int32_t nt_status;
+
+#define NT_STATUS_SUCCESS ((nt_status) 0x00000000)
+
+#define NT_DBG_APP_NOT_IDLE ((nt_status) 0xC0010002)
+#define NT_DBG_COMMAND_EXCEPTION ((nt_status) 0x40010009)
+#define NT_DBG_CONTINUE ((nt_status) 0x00010002)
+#define NT_DBG_CONTROL_BREAK ((nt_status) 0x40010008)
+#define NT_DBG_CONTROL_C ((nt_status) 0x40010005)
+#define NT_DBG_EXCEPTION_HANDLED ((nt_status) 0x00010001)
+#define NT_DBG_EXCEPTION_NOT_HANDLED ((nt_status) 0x80010001)
+#define NT_DBG_NO_STATE_CHANGE ((nt_status) 0xC0010001)
+#define NT_DBG_PRINTEXCEPTION_C ((nt_status) 0x40010006)
+#define NT_DBG_REPLY_LATER ((nt_status) 0x40010001)
+#define NT_DBG_RIPEXCEPTION ((nt_status) 0x40010007)
+#define NT_DBG_TERMINATE_PROCESS ((nt_status) 0x40010004)
+#define NT_DBG_TERMINATE_THREAD ((nt_status) 0x40010003)
+#define NT_DBG_UNABLE_TO_PROVIDE_HANDLE ((nt_status) 0x40010002)
+#define NT_EPT_NT_CANT_CREATE ((nt_status) 0xC002004C)
+#define NT_EPT_NT_CANT_PERFORM_OP ((nt_status) 0xC0020035)
+#define NT_EPT_NT_INVALID_ENTRY ((nt_status) 0xC0020034)
+#define NT_EPT_NT_NOT_REGISTERED ((nt_status) 0xC0020036)
+#define NT_RPC_NT_ADDRESS_ERROR ((nt_status) 0xC0020045)
+#define NT_RPC_NT_ALREADY_LISTENING ((nt_status) 0xC002000E)
+#define NT_RPC_NT_ALREADY_REGISTERED ((nt_status) 0xC002000C)
+#define NT_RPC_NT_BAD_STUB_DATA ((nt_status) 0xC003000C)
+#define NT_RPC_NT_BINDING_HAS_NO_AUTH ((nt_status) 0xC002002F)
+#define NT_RPC_NT_BINDING_INCOMPLETE ((nt_status) 0xC0020051)
+#define NT_RPC_NT_BYTE_COUNT_TOO_SMALL ((nt_status) 0xC003000B)
+#define NT_RPC_NT_CALL_CANCELLED ((nt_status) 0xC0020050)
+#define NT_RPC_NT_CALL_FAILED ((nt_status) 0xC002001B)
+#define NT_RPC_NT_CALL_FAILED_DNE ((nt_status) 0xC002001C)
+#define NT_RPC_NT_CALL_IN_PROGRESS ((nt_status) 0xC0020049)
+#define NT_RPC_NT_CANNOT_SUPPORT ((nt_status) 0xC0020041)
+#define NT_RPC_NT_CANT_CREATE_ENDPOINT ((nt_status) 0xC0020015)
+#define NT_RPC_NT_COMM_FAILURE ((nt_status) 0xC0020052)
+#define NT_RPC_NT_DUPLICATE_ENDPOINT ((nt_status) 0xC0020029)
+#define NT_RPC_NT_ENTRY_ALREADY_EXISTS ((nt_status) 0xC002003D)
+#define NT_RPC_NT_ENTRY_NOT_FOUND ((nt_status) 0xC002003E)
+#define NT_RPC_NT_ENUM_VALUE_OUT_OF_RANGE ((nt_status) 0xC003000A)
+#define NT_RPC_NT_FP_DIV_ZERO ((nt_status) 0xC0020046)
+#define NT_RPC_NT_FP_OVERFLOW ((nt_status) 0xC0020048)
+#define NT_RPC_NT_FP_UNDERFLOW ((nt_status) 0xC0020047)
+#define NT_RPC_NT_GROUP_MEMBER_NOT_FOUND ((nt_status) 0xC002004B)
+#define NT_RPC_NT_INCOMPLETE_NAME ((nt_status) 0xC0020038)
+#define NT_RPC_NT_INTERFACE_NOT_FOUND ((nt_status) 0xC002003C)
+#define NT_RPC_NT_INTERNAL_ERROR ((nt_status) 0xC0020043)
+#define NT_RPC_NT_INVALID_ASYNC_CALL ((nt_status) 0xC0020063)
+#define NT_RPC_NT_INVALID_ASYNC_HANDLE ((nt_status) 0xC0020062)
+#define NT_RPC_NT_INVALID_AUTH_IDENTITY ((nt_status) 0xC0020032)
+#define NT_RPC_NT_INVALID_BINDING ((nt_status) 0xC0020003)
+#define NT_RPC_NT_INVALID_BOUND ((nt_status) 0xC0020023)
+#define NT_RPC_NT_INVALID_ENDPOINT_FORMAT ((nt_status) 0xC0020007)
+#define NT_RPC_NT_INVALID_ES_ACTION ((nt_status) 0xC0030059)
+#define NT_RPC_NT_INVALID_NAF_ID ((nt_status) 0xC0020040)
+#define NT_RPC_NT_INVALID_NAME_SYNTAX ((nt_status) 0xC0020025)
+#define NT_RPC_NT_INVALID_NETWORK_OPTIONS ((nt_status) 0xC0020019)
+#define NT_RPC_NT_INVALID_NET_ADDR ((nt_status) 0xC0020008)
+#define NT_RPC_NT_INVALID_OBJECT ((nt_status) 0xC002004D)
+#define NT_RPC_NT_INVALID_PIPE_OBJECT ((nt_status) 0xC003005C)
+#define NT_RPC_NT_INVALID_PIPE_OPERATION ((nt_status) 0xC003005D)
+#define NT_RPC_NT_INVALID_RPC_PROTSEQ ((nt_status) 0xC0020005)
+#define NT_RPC_NT_INVALID_STRING_BINDING ((nt_status) 0xC0020001)
+#define NT_RPC_NT_INVALID_STRING_UUID ((nt_status) 0xC0020006)
+#define NT_RPC_NT_INVALID_TAG ((nt_status) 0xC0020022)
+#define NT_RPC_NT_INVALID_TIMEOUT ((nt_status) 0xC002000A)
+#define NT_RPC_NT_INVALID_VERS_OPTION ((nt_status) 0xC0020039)
+#define NT_RPC_NT_MAX_CALLS_TOO_SMALL ((nt_status) 0xC002002B)
+#define NT_RPC_NT_NAME_SERVICE_UNAVAILABLE ((nt_status) 0xC002003F)
+#define NT_RPC_NT_NOTHING_TO_EXPORT ((nt_status) 0xC0020037)
+#define NT_RPC_NT_NOT_ALL_OBJS_UNEXPORTED ((nt_status) 0xC002003B)
+#define NT_RPC_NT_NOT_CANCELLED ((nt_status) 0xC0020058)
+#define NT_RPC_NT_NOT_LISTENING ((nt_status) 0xC0020010)
+#define NT_RPC_NT_NOT_RPC_ERROR ((nt_status) 0xC0020055)
+#define NT_RPC_NT_NO_BINDINGS ((nt_status) 0xC0020013)
+#define NT_RPC_NT_NO_CALL_ACTIVE ((nt_status) 0xC002001A)
+#define NT_RPC_NT_NO_CONTEXT_AVAILABLE ((nt_status) 0xC0020042)
+#define NT_RPC_NT_NO_ENDPOINT_FOUND ((nt_status) 0xC0020009)
+#define NT_RPC_NT_NO_ENTRY_NAME ((nt_status) 0xC0020024)
+#define NT_RPC_NT_NO_INTERFACES ((nt_status) 0xC002004F)
+#define NT_RPC_NT_NO_MORE_BINDINGS ((nt_status) 0xC002004A)
+#define NT_RPC_NT_NO_MORE_ENTRIES ((nt_status) 0xC0030001)
+#define NT_RPC_NT_NO_MORE_MEMBERS ((nt_status) 0xC002003A)
+#define NT_RPC_NT_NO_PRINC_NAME ((nt_status) 0xC0020054)
+#define NT_RPC_NT_NO_PROTSEQS ((nt_status) 0xC0020014)
+#define NT_RPC_NT_NO_PROTSEQS_REGISTERED ((nt_status) 0xC002000F)
+#define NT_RPC_NT_NULL_REF_POINTER ((nt_status) 0xC0030009)
+#define NT_RPC_NT_OBJECT_NOT_FOUND ((nt_status) 0xC002000B)
+#define NT_RPC_NT_OUT_OF_RESOURCES ((nt_status) 0xC0020016)
+#define NT_RPC_NT_PIPE_CLOSED ((nt_status) 0xC003005F)
+#define NT_RPC_NT_PIPE_DISCIPLINE_ERROR ((nt_status) 0xC0030060)
+#define NT_RPC_NT_PIPE_EMPTY ((nt_status) 0xC0030061)
+#define NT_RPC_NT_PROCNUM_OUT_OF_RANGE ((nt_status) 0xC002002E)
+#define NT_RPC_NT_PROTOCOL_ERROR ((nt_status) 0xC002001D)
+#define NT_RPC_NT_PROTSEQ_NOT_FOUND ((nt_status) 0xC002002D)
+#define NT_RPC_NT_PROTSEQ_NOT_SUPPORTED ((nt_status) 0xC0020004)
+#define NT_RPC_NT_PROXY_ACCESS_DENIED ((nt_status) 0xC0020064)
+#define NT_RPC_NT_SEC_PKG_ERROR ((nt_status) 0xC0020057)
+#define NT_RPC_NT_SEND_INCOMPLETE ((nt_status) 0x400200AF)
+#define NT_RPC_NT_SERVER_TOO_BUSY ((nt_status) 0xC0020018)
+#define NT_RPC_NT_SERVER_UNAVAILABLE ((nt_status) 0xC0020017)
+#define NT_RPC_NT_SS_CANNOT_GET_CALL_HANDLE ((nt_status) 0xC0030008)
+#define NT_RPC_NT_SS_CHAR_TRANS_OPEN_FAIL ((nt_status) 0xC0030002)
+#define NT_RPC_NT_SS_CHAR_TRANS_SHORT_FILE ((nt_status) 0xC0030003)
+#define NT_RPC_NT_SS_CONTEXT_DAMAGED ((nt_status) 0xC0030006)
+#define NT_RPC_NT_SS_CONTEXT_MISMATCH ((nt_status) 0xC0030005)
+#define NT_RPC_NT_SS_HANDLES_MISMATCH ((nt_status) 0xC0030007)
+#define NT_RPC_NT_SS_IN_NULL_CONTEXT ((nt_status) 0xC0030004)
+#define NT_RPC_NT_STRING_TOO_LONG ((nt_status) 0xC002002C)
+#define NT_RPC_NT_TYPE_ALREADY_REGISTERED ((nt_status) 0xC002000D)
+#define NT_RPC_NT_UNKNOWN_AUTHN_LEVEL ((nt_status) 0xC0020031)
+#define NT_RPC_NT_UNKNOWN_AUTHN_SERVICE ((nt_status) 0xC0020030)
+#define NT_RPC_NT_UNKNOWN_AUTHN_TYPE ((nt_status) 0xC002002A)
+#define NT_RPC_NT_UNKNOWN_AUTHZ_SERVICE ((nt_status) 0xC0020033)
+#define NT_RPC_NT_UNKNOWN_IF ((nt_status) 0xC0020012)
+#define NT_RPC_NT_UNKNOWN_MGR_TYPE ((nt_status) 0xC0020011)
+#define NT_RPC_NT_UNSUPPORTED_AUTHN_LEVEL ((nt_status) 0xC0020053)
+#define NT_RPC_NT_UNSUPPORTED_NAME_SYNTAX ((nt_status) 0xC0020026)
+#define NT_RPC_NT_UNSUPPORTED_TRANS_SYN ((nt_status) 0xC002001F)
+#define NT_RPC_NT_UNSUPPORTED_TYPE ((nt_status) 0xC0020021)
+#define NT_RPC_NT_UUID_LOCAL_ONLY ((nt_status) 0x40020056)
+#define NT_RPC_NT_UUID_NO_ADDRESS ((nt_status) 0xC0020028)
+#define NT_RPC_NT_WRONG_ES_VERSION ((nt_status) 0xC003005A)
+#define NT_RPC_NT_WRONG_KIND_OF_BINDING ((nt_status) 0xC0020002)
+#define NT_RPC_NT_WRONG_PIPE_VERSION ((nt_status) 0xC003005E)
+#define NT_RPC_NT_WRONG_STUB_VERSION ((nt_status) 0xC003005B)
+#define NT_RPC_NT_ZERO_DIVIDE ((nt_status) 0xC0020044)
+#define NT_STATUS_ABANDONED ((nt_status) 0x00000080)
+#define NT_STATUS_ABANDONED_WAIT_0 ((nt_status) 0x00000080)
+#define NT_STATUS_ABANDONED_WAIT_63 ((nt_status) 0x000000BF)
+#define NT_STATUS_ABANDON_HIBERFILE ((nt_status) 0x40000033)
+#define NT_STATUS_ACCESS_AUDIT_BY_POLICY ((nt_status) 0x40000032)
+#define NT_STATUS_ACCESS_DENIED ((nt_status) 0xC0000022)
+#define NT_STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT ((nt_status) 0xC0000361)
+#define NT_STATUS_ACCESS_DISABLED_BY_POLICY_OTHER ((nt_status) 0xC0000364)
+#define NT_STATUS_ACCESS_DISABLED_BY_POLICY_PATH ((nt_status) 0xC0000362)
+#define NT_STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER ((nt_status) 0xC0000363)
+#define NT_STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY ((nt_status) 0xC0000372)
+#define NT_STATUS_ACCESS_VIOLATION ((nt_status) 0xC0000005)
+#define NT_STATUS_ACCOUNT_DISABLED ((nt_status) 0xC0000072)
+#define NT_STATUS_ACCOUNT_EXPIRED ((nt_status) 0xC0000193)
+#define NT_STATUS_ACCOUNT_LOCKED_OUT ((nt_status) 0xC0000234)
+#define NT_STATUS_ACCOUNT_RESTRICTION ((nt_status) 0xC000006E)
+#define NT_STATUS_ACPI_ACQUIRE_GLOBAL_LOCK ((nt_status) 0xC0140012)
+#define NT_STATUS_ACPI_ADDRESS_NOT_MAPPED ((nt_status) 0xC014000C)
+#define NT_STATUS_ACPI_ALREADY_INITIALIZED ((nt_status) 0xC0140013)
+#define NT_STATUS_ACPI_ASSERT_FAILED ((nt_status) 0xC0140003)
+#define NT_STATUS_ACPI_FATAL ((nt_status) 0xC0140006)
+#define NT_STATUS_ACPI_HANDLER_COLLISION ((nt_status) 0xC014000E)
+#define NT_STATUS_ACPI_INCORRECT_ARGUMENT_COUNT ((nt_status) 0xC014000B)
+#define NT_STATUS_ACPI_INVALID_ACCESS_SIZE ((nt_status) 0xC0140011)
+#define NT_STATUS_ACPI_INVALID_ARGTYPE ((nt_status) 0xC0140008)
+#define NT_STATUS_ACPI_INVALID_ARGUMENT ((nt_status) 0xC0140005)
+#define NT_STATUS_ACPI_INVALID_DATA ((nt_status) 0xC014000F)
+#define NT_STATUS_ACPI_INVALID_EVENTTYPE ((nt_status) 0xC014000D)
+#define NT_STATUS_ACPI_INVALID_INDEX ((nt_status) 0xC0140004)
+#define NT_STATUS_ACPI_INVALID_MUTEX_LEVEL ((nt_status) 0xC0140015)
+#define NT_STATUS_ACPI_INVALID_OBJTYPE ((nt_status) 0xC0140009)
+#define NT_STATUS_ACPI_INVALID_OPCODE ((nt_status) 0xC0140001)
+#define NT_STATUS_ACPI_INVALID_REGION ((nt_status) 0xC0140010)
+#define NT_STATUS_ACPI_INVALID_SUPERNAME ((nt_status) 0xC0140007)
+#define NT_STATUS_ACPI_INVALID_TABLE ((nt_status) 0xC0140019)
+#define NT_STATUS_ACPI_INVALID_TARGETTYPE ((nt_status) 0xC014000A)
+#define NT_STATUS_ACPI_MUTEX_NOT_OWNED ((nt_status) 0xC0140016)
+#define NT_STATUS_ACPI_MUTEX_NOT_OWNER ((nt_status) 0xC0140017)
+#define NT_STATUS_ACPI_NOT_INITIALIZED ((nt_status) 0xC0140014)
+#define NT_STATUS_ACPI_POWER_REQUEST_FAILED ((nt_status) 0xC0140021)
+#define NT_STATUS_ACPI_REG_HANDLER_FAILED ((nt_status) 0xC0140020)
+#define NT_STATUS_ACPI_RS_ACCESS ((nt_status) 0xC0140018)
+#define NT_STATUS_ACPI_STACK_OVERFLOW ((nt_status) 0xC0140002)
+#define NT_STATUS_ADAPTER_HARDWARE_ERROR ((nt_status) 0xC00000C2)
+#define NT_STATUS_ADDRESS_ALREADY_ASSOCIATED ((nt_status) 0xC0000238)
+#define NT_STATUS_ADDRESS_ALREADY_EXISTS ((nt_status) 0xC000020A)
+#define NT_STATUS_ADDRESS_CLOSED ((nt_status) 0xC000020B)
+#define NT_STATUS_ADDRESS_NOT_ASSOCIATED ((nt_status) 0xC0000239)
+#define NT_STATUS_ADVANCED_INSTALLER_FAILED ((nt_status) 0xC0150020)
+#define NT_STATUS_AGENTS_EXHAUSTED ((nt_status) 0xC0000085)
+#define NT_STATUS_ALERTED ((nt_status) 0x00000101)
+#define NT_STATUS_ALIAS_EXISTS ((nt_status) 0xC0000154)
+#define NT_STATUS_ALLOCATE_BUCKET ((nt_status) 0xC000022F)
+#define NT_STATUS_ALLOTTED_SPACE_EXCEEDED ((nt_status) 0xC0000099)
+#define NT_STATUS_ALL_SIDS_FILTERED ((nt_status) 0xC000035E)
+#define NT_STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED ((nt_status) 0xC0000402)
+#define NT_STATUS_ALPC_CHECK_COMPLETION_LIST ((nt_status) 0x40000030)
+#define NT_STATUS_ALREADY_COMMITTED ((nt_status) 0xC0000021)
+#define NT_STATUS_ALREADY_DISCONNECTED ((nt_status) 0x80000025)
+#define NT_STATUS_ALREADY_REGISTERED ((nt_status) 0xC0000718)
+#define NT_STATUS_ALREADY_WIN32 ((nt_status) 0x4000001B)
+#define NT_STATUS_AMBIGUOUS_SYSTEM_DEVICE ((nt_status) 0xC0000451)
+#define NT_STATUS_APC_RETURNED_WHILE_IMPERSONATING ((nt_status) 0xC0000711)
+#define NT_STATUS_APPHELP_BLOCK ((nt_status) 0xC000035D)
+#define NT_STATUS_APP_INIT_FAILURE ((nt_status) 0xC0000145)
+#define NT_STATUS_ARBITRATION_UNHANDLED ((nt_status) 0x40000026)
+#define NT_STATUS_ARRAY_BOUNDS_EXCEEDED ((nt_status) 0xC000008C)
+#define NT_STATUS_ASSERTION_FAILURE ((nt_status) 0xC0000420)
+#define NT_STATUS_AUDITING_DISABLED ((nt_status) 0xC0000356)
+#define NT_STATUS_AUDIT_FAILED ((nt_status) 0xC0000244)
+#define NT_STATUS_AUTHENTICATION_FIREWALL_FAILED ((nt_status) 0xC0000413)
+#define NT_STATUS_AUTHIP_FAILURE ((nt_status) 0xC000A086)
+#define NT_STATUS_BACKUP_CONTROLLER ((nt_status) 0xC0000187)
+#define NT_STATUS_BAD_BINDINGS ((nt_status) 0xC000035B)
+#define NT_STATUS_BAD_CLUSTERS ((nt_status) 0xC0000805)
+#define NT_STATUS_BAD_COMPRESSION_BUFFER ((nt_status) 0xC0000242)
+#define NT_STATUS_BAD_CURRENT_DIRECTORY ((nt_status) 0x40000007)
+#define NT_STATUS_BAD_DESCRIPTOR_FORMAT ((nt_status) 0xC00000E7)
+#define NT_STATUS_BAD_DEVICE_TYPE ((nt_status) 0xC00000CB)
+#define NT_STATUS_BAD_DLL_ENTRYPOINT ((nt_status) 0xC0000251)
+#define NT_STATUS_BAD_FILE_TYPE ((nt_status) 0xC0000903)
+#define NT_STATUS_BAD_FUNCTION_TABLE ((nt_status) 0xC00000FF)
+#define NT_STATUS_BAD_IMPERSONATION_LEVEL ((nt_status) 0xC00000A5)
+#define NT_STATUS_BAD_INHERITANCE_ACL ((nt_status) 0xC000007D)
+#define NT_STATUS_BAD_INITIAL_PC ((nt_status) 0xC000000A)
+#define NT_STATUS_BAD_INITIAL_STACK ((nt_status) 0xC0000009)
+#define NT_STATUS_BAD_LOGON_SESSION_STATE ((nt_status) 0xC0000104)
+#define NT_STATUS_BAD_MASTER_BOOT_RECORD ((nt_status) 0xC00000A9)
+#define NT_STATUS_BAD_MCFG_TABLE ((nt_status) 0xC0000908)
+#define NT_STATUS_BAD_NETWORK_NAME ((nt_status) 0xC00000CC)
+#define NT_STATUS_BAD_NETWORK_PATH ((nt_status) 0xC00000BE)
+#define NT_STATUS_BAD_REMOTE_ADAPTER ((nt_status) 0xC00000C5)
+#define NT_STATUS_BAD_SERVICE_ENTRYPOINT ((nt_status) 0xC0000252)
+#define NT_STATUS_BAD_STACK ((nt_status) 0xC0000028)
+#define NT_STATUS_BAD_TOKEN_TYPE ((nt_status) 0xC00000A8)
+#define NT_STATUS_BAD_VALIDATION_CLASS ((nt_status) 0xC00000A7)
+#define NT_STATUS_BAD_WORKING_SET_LIMIT ((nt_status) 0xC000004C)
+#define NT_STATUS_BEGINNING_OF_MEDIA ((nt_status) 0x8000001F)
+#define NT_STATUS_BEYOND_VDL ((nt_status) 0xC0000432)
+#define NT_STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT ((nt_status) 0xC000016E)
+#define NT_STATUS_BIZRULES_NOT_ENABLED ((nt_status) 0x40000034)
+#define NT_STATUS_BREAKPOINT ((nt_status) 0x80000003)
+#define NT_STATUS_BUFFER_ALL_ZEROS ((nt_status) 0x00000117)
+#define NT_STATUS_BUFFER_OVERFLOW ((nt_status) 0x80000005)
+#define NT_STATUS_BUFFER_TOO_SMALL ((nt_status) 0xC0000023)
+#define NT_STATUS_BUS_RESET ((nt_status) 0x8000001D)
+#define NT_STATUS_CACHE_PAGE_LOCKED ((nt_status) 0x00000115)
+#define NT_STATUS_CALLBACK_BYPASS ((nt_status) 0xC0000503)
+#define NT_STATUS_CALLBACK_POP_STACK ((nt_status) 0xC0000423)
+#define NT_STATUS_CALLBACK_RETURNED_LANG ((nt_status) 0xC000071F)
+#define NT_STATUS_CALLBACK_RETURNED_LDR_LOCK ((nt_status) 0xC000071E)
+#define NT_STATUS_CALLBACK_RETURNED_PRI_BACK ((nt_status) 0xC0000720)
+#define NT_STATUS_CALLBACK_RETURNED_THREAD_AFFINITY ((nt_status) 0xC0000721)
+#define NT_STATUS_CALLBACK_RETURNED_THREAD_PRIORITY ((nt_status) 0xC000071B)
+#define NT_STATUS_CALLBACK_RETURNED_TRANSACTION ((nt_status) 0xC000071D)
+#define NT_STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING ((nt_status) 0xC0000710)
+#define NT_STATUS_CANCELLED ((nt_status) 0xC0000120)
+#define NT_STATUS_CANNOT_ABORT_TRANSACTIONS ((nt_status) 0xC019004D)
+#define NT_STATUS_CANNOT_ACCEPT_TRANSACTED_WORK ((nt_status) 0xC019004C)
+#define NT_STATUS_CANNOT_BREAK_OPLOCK ((nt_status) 0xC0000909)
+#define NT_STATUS_CANNOT_DELETE ((nt_status) 0xC0000121)
+#define NT_STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION ((nt_status) 0xC0190044)
+#define NT_STATUS_CANNOT_IMPERSONATE ((nt_status) 0xC000010D)
+#define NT_STATUS_CANNOT_LOAD_REGISTRY_FILE ((nt_status) 0xC0000218)
+#define NT_STATUS_CANNOT_MAKE ((nt_status) 0xC00002EA)
+#define NT_STATUS_CANT_ACCESS_DOMAIN_INFO ((nt_status) 0xC00000DA)
+#define NT_STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY ((nt_status) 0xC0190037)
+#define NT_STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS ((nt_status) 0xC0190026)
+#define NT_STATUS_CANT_CROSS_RM_BOUNDARY ((nt_status) 0xC0190038)
+#define NT_STATUS_CANT_DISABLE_MANDATORY ((nt_status) 0xC000005D)
+#define NT_STATUS_CANT_ENABLE_DENY_ONLY ((nt_status) 0xC00002B3)
+#define NT_STATUS_CANT_OPEN_ANONYMOUS ((nt_status) 0xC00000A6)
+#define NT_STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT ((nt_status) 0xC0190025)
+#define NT_STATUS_CANT_RECOVER_WITH_HANDLE_OPEN ((nt_status) 0x80190031)
+#define NT_STATUS_CANT_TERMINATE_SELF ((nt_status) 0xC00000DB)
+#define NT_STATUS_CANT_WAIT ((nt_status) 0xC00000D8)
+#define NT_STATUS_CARDBUS_NOT_SUPPORTED ((nt_status) 0x40000027)
+#define NT_STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE ((nt_status) 0xC0000714)
+#define NT_STATUS_CHECKING_FILE_SYSTEM ((nt_status) 0x40000014)
+#define NT_STATUS_CHECKOUT_REQUIRED ((nt_status) 0xC0000902)
+#define NT_STATUS_CHILD_MUST_BE_VOLATILE ((nt_status) 0xC0000181)
+#define NT_STATUS_CLEANER_CARTRIDGE_INSTALLED ((nt_status) 0x80000027)
+#define NT_STATUS_CLIENT_SERVER_PARAMETERS_INVALID ((nt_status) 0xC0000223)
+#define NT_STATUS_CLUSTER_INVALID_NETWORK ((nt_status) 0xC0130010)
+#define NT_STATUS_CLUSTER_INVALID_NETWORK_PROVIDER ((nt_status) 0xC013000B)
+#define NT_STATUS_CLUSTER_INVALID_NODE ((nt_status) 0xC0130001)
+#define NT_STATUS_CLUSTER_INVALID_REQUEST ((nt_status) 0xC013000A)
+#define NT_STATUS_CLUSTER_JOIN_IN_PROGRESS ((nt_status) 0xC0130003)
+#define NT_STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS ((nt_status) 0xC013000F)
+#define NT_STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND ((nt_status) 0xC0130005)
+#define NT_STATUS_CLUSTER_NETINTERFACE_EXISTS ((nt_status) 0xC0130008)
+#define NT_STATUS_CLUSTER_NETINTERFACE_NOT_FOUND ((nt_status) 0xC0130009)
+#define NT_STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE ((nt_status) 0x80130004)
+#define NT_STATUS_CLUSTER_NETWORK_ALREADY_ONLINE ((nt_status) 0x80130003)
+#define NT_STATUS_CLUSTER_NETWORK_EXISTS ((nt_status) 0xC0130006)
+#define NT_STATUS_CLUSTER_NETWORK_NOT_FOUND ((nt_status) 0xC0130007)
+#define NT_STATUS_CLUSTER_NETWORK_NOT_INTERNAL ((nt_status) 0xC0130016)
+#define NT_STATUS_CLUSTER_NODE_ALREADY_DOWN ((nt_status) 0x80130002)
+#define NT_STATUS_CLUSTER_NODE_ALREADY_MEMBER ((nt_status) 0x80130005)
+#define NT_STATUS_CLUSTER_NODE_ALREADY_UP ((nt_status) 0x80130001)
+#define NT_STATUS_CLUSTER_NODE_DOWN ((nt_status) 0xC013000C)
+#define NT_STATUS_CLUSTER_NODE_EXISTS ((nt_status) 0xC0130002)
+#define NT_STATUS_CLUSTER_NODE_NOT_FOUND ((nt_status) 0xC0130004)
+#define NT_STATUS_CLUSTER_NODE_NOT_MEMBER ((nt_status) 0xC013000E)
+#define NT_STATUS_CLUSTER_NODE_NOT_PAUSED ((nt_status) 0xC0130014)
+#define NT_STATUS_CLUSTER_NODE_PAUSED ((nt_status) 0xC0130013)
+#define NT_STATUS_CLUSTER_NODE_UNREACHABLE ((nt_status) 0xC013000D)
+#define NT_STATUS_CLUSTER_NODE_UP ((nt_status) 0xC0130012)
+#define NT_STATUS_CLUSTER_NO_NET_ADAPTERS ((nt_status) 0xC0130011)
+#define NT_STATUS_CLUSTER_NO_SECURITY_CONTEXT ((nt_status) 0xC0130015)
+#define NT_STATUS_CLUSTER_POISONED ((nt_status) 0xC0130017)
+#define NT_STATUS_COMMITMENT_LIMIT ((nt_status) 0xC000012D)
+#define NT_STATUS_COMMITMENT_MINIMUM ((nt_status) 0xC00002C8)
+#define NT_STATUS_COMPRESSION_DISABLED ((nt_status) 0xC0000426)
+#define NT_STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION ((nt_status) 0xC0190056)
+#define NT_STATUS_CONFLICTING_ADDRESSES ((nt_status) 0xC0000018)
+#define NT_STATUS_CONNECTION_ABORTED ((nt_status) 0xC0000241)
+#define NT_STATUS_CONNECTION_ACTIVE ((nt_status) 0xC000023B)
+#define NT_STATUS_CONNECTION_COUNT_LIMIT ((nt_status) 0xC0000246)
+#define NT_STATUS_CONNECTION_DISCONNECTED ((nt_status) 0xC000020C)
+#define NT_STATUS_CONNECTION_INVALID ((nt_status) 0xC000023A)
+#define NT_STATUS_CONNECTION_IN_USE ((nt_status) 0xC0000108)
+#define NT_STATUS_CONNECTION_REFUSED ((nt_status) 0xC0000236)
+#define NT_STATUS_CONNECTION_RESET ((nt_status) 0xC000020D)
+#define NT_STATUS_CONTENT_BLOCKED ((nt_status) 0xC0000804)
+#define NT_STATUS_CONTEXT_MISMATCH ((nt_status) 0xC0000719)
+#define NT_STATUS_CONTROL_C_EXIT ((nt_status) 0xC000013A)
+#define NT_STATUS_CONVERT_TO_LARGE ((nt_status) 0xC000022C)
+#define NT_STATUS_COPY_PROTECTION_FAILURE ((nt_status) 0xC0000305)
+#define NT_STATUS_CORRUPT_SYSTEM_FILE ((nt_status) 0xC00002C4)
+#define NT_STATUS_COULD_NOT_INTERPRET ((nt_status) 0xC00000B9)
+#define NT_STATUS_COULD_NOT_RESIZE_LOG ((nt_status) 0x80190009)
+#define NT_STATUS_CRASH_DUMP ((nt_status) 0x00000116)
+#define NT_STATUS_CRC_ERROR ((nt_status) 0xC000003F)
+#define NT_STATUS_CRED_REQUIRES_CONFIRMATION ((nt_status) 0xC0000440)
+#define NT_STATUS_CRM_PROTOCOL_ALREADY_EXISTS ((nt_status) 0xC019000F)
+#define NT_STATUS_CRM_PROTOCOL_NOT_FOUND ((nt_status) 0xC0190011)
+#define NT_STATUS_CROSSREALM_DELEGATION_FAILURE ((nt_status) 0xC000040B)
+#define NT_STATUS_CRYPTO_SYSTEM_INVALID ((nt_status) 0xC00002F3)
+#define NT_STATUS_CSS_AUTHENTICATION_FAILURE ((nt_status) 0xC0000306)
+#define NT_STATUS_CSS_KEY_NOT_ESTABLISHED ((nt_status) 0xC0000308)
+#define NT_STATUS_CSS_KEY_NOT_PRESENT ((nt_status) 0xC0000307)
+#define NT_STATUS_CSS_REGION_MISMATCH ((nt_status) 0xC000030A)
+#define NT_STATUS_CSS_RESETS_EXHAUSTED ((nt_status) 0xC000030B)
+#define NT_STATUS_CSS_SCRAMBLED_SECTOR ((nt_status) 0xC0000309)
+#define NT_STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE ((nt_status) 0xC0000443)
+#define NT_STATUS_CS_ENCRYPTION_FILE_NOT_CSE ((nt_status) 0xC0000445)
+#define NT_STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE ((nt_status) 0xC0000441)
+#define NT_STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE ((nt_status) 0xC0000444)
+#define NT_STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER ((nt_status) 0xC0000442)
+#define NT_STATUS_CTL_FILE_NOT_SUPPORTED ((nt_status) 0xC0000057)
+#define NT_STATUS_CTX_BAD_VIDEO_MODE ((nt_status) 0xC00A0018)
+#define NT_STATUS_CTX_CDM_CONNECT ((nt_status) 0x400A0004)
+#define NT_STATUS_CTX_CDM_DISCONNECT ((nt_status) 0x400A0005)
+#define NT_STATUS_CTX_CLIENT_LICENSE_IN_USE ((nt_status) 0xC00A0034)
+#define NT_STATUS_CTX_CLIENT_LICENSE_NOT_SET ((nt_status) 0xC00A0033)
+#define NT_STATUS_CTX_CLIENT_QUERY_TIMEOUT ((nt_status) 0xC00A0026)
+#define NT_STATUS_CTX_CLOSE_PENDING ((nt_status) 0xC00A0006)
+#define NT_STATUS_CTX_CONSOLE_CONNECT ((nt_status) 0xC00A0028)
+#define NT_STATUS_CTX_CONSOLE_DISCONNECT ((nt_status) 0xC00A0027)
+#define NT_STATUS_CTX_GRAPHICS_INVALID ((nt_status) 0xC00A0022)
+#define NT_STATUS_CTX_INVALID_MODEMNAME ((nt_status) 0xC00A0009)
+#define NT_STATUS_CTX_INVALID_PD ((nt_status) 0xC00A0002)
+#define NT_STATUS_CTX_INVALID_WD ((nt_status) 0xC00A002E)
+#define NT_STATUS_CTX_LICENSE_CLIENT_INVALID ((nt_status) 0xC00A0012)
+#define NT_STATUS_CTX_LICENSE_EXPIRED ((nt_status) 0xC00A0014)
+#define NT_STATUS_CTX_LICENSE_NOT_AVAILABLE ((nt_status) 0xC00A0013)
+#define NT_STATUS_CTX_LOGON_DISABLED ((nt_status) 0xC00A0037)
+#define NT_STATUS_CTX_MODEM_INF_NOT_FOUND ((nt_status) 0xC00A0008)
+#define NT_STATUS_CTX_MODEM_RESPONSE_BUSY ((nt_status) 0xC00A000E)
+#define NT_STATUS_CTX_MODEM_RESPONSE_NO_CARRIER ((nt_status) 0xC00A000C)
+#define NT_STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE ((nt_status) 0xC00A000D)
+#define NT_STATUS_CTX_MODEM_RESPONSE_TIMEOUT ((nt_status) 0xC00A000B)
+#define NT_STATUS_CTX_MODEM_RESPONSE_VOICE ((nt_status) 0xC00A000F)
+#define NT_STATUS_CTX_NOT_CONSOLE ((nt_status) 0xC00A0024)
+#define NT_STATUS_CTX_NO_OUTBUF ((nt_status) 0xC00A0007)
+#define NT_STATUS_CTX_PD_NOT_FOUND ((nt_status) 0xC00A0003)
+#define NT_STATUS_CTX_RESPONSE_ERROR ((nt_status) 0xC00A000A)
+#define NT_STATUS_CTX_SECURITY_LAYER_ERROR ((nt_status) 0xC00A0038)
+#define NT_STATUS_CTX_SHADOW_DENIED ((nt_status) 0xC00A002A)
+#define NT_STATUS_CTX_SHADOW_DISABLED ((nt_status) 0xC00A0031)
+#define NT_STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE ((nt_status) 0xC00A0035)
+#define NT_STATUS_CTX_SHADOW_INVALID ((nt_status) 0xC00A0030)
+#define NT_STATUS_CTX_SHADOW_NOT_RUNNING ((nt_status) 0xC00A0036)
+#define NT_STATUS_CTX_TD_ERROR ((nt_status) 0xC00A0010)
+#define NT_STATUS_CTX_WD_NOT_FOUND ((nt_status) 0xC00A002F)
+#define NT_STATUS_CTX_WINSTATION_ACCESS_DENIED ((nt_status) 0xC00A002B)
+#define NT_STATUS_CTX_WINSTATION_BUSY ((nt_status) 0xC00A0017)
+#define NT_STATUS_CTX_WINSTATION_NAME_COLLISION ((nt_status) 0xC00A0016)
+#define NT_STATUS_CTX_WINSTATION_NAME_INVALID ((nt_status) 0xC00A0001)
+#define NT_STATUS_CTX_WINSTATION_NOT_FOUND ((nt_status) 0xC00A0015)
+#define NT_STATUS_CURRENT_DOMAIN_NOT_ALLOWED ((nt_status) 0xC00002E9)
+#define NT_STATUS_CURRENT_TRANSACTION_NOT_VALID ((nt_status) 0xC0190018)
+#define NT_STATUS_DATATYPE_MISALIGNMENT ((nt_status) 0x80000002)
+#define NT_STATUS_DATATYPE_MISALIGNMENT_ERROR ((nt_status) 0xC00002C5)
+#define NT_STATUS_DATA_ERROR ((nt_status) 0xC000003E)
+#define NT_STATUS_DATA_LATE_ERROR ((nt_status) 0xC000003D)
+#define NT_STATUS_DATA_LOST_REPAIR ((nt_status) 0x80000803)
+#define NT_STATUS_DATA_NOT_ACCEPTED ((nt_status) 0xC000021B)
+#define NT_STATUS_DATA_OVERRUN ((nt_status) 0xC000003C)
+#define NT_STATUS_DEBUGGER_INACTIVE ((nt_status) 0xC0000354)
+#define NT_STATUS_DEBUG_ATTACH_FAILED ((nt_status) 0xC0000219)
+#define NT_STATUS_DECRYPTION_FAILED ((nt_status) 0xC000028B)
+#define NT_STATUS_DELAY_LOAD_FAILED ((nt_status) 0xC0000412)
+#define NT_STATUS_DELETE_PENDING ((nt_status) 0xC0000056)
+#define NT_STATUS_DESTINATION_ELEMENT_FULL ((nt_status) 0xC0000284)
+#define NT_STATUS_DEVICE_ALREADY_ATTACHED ((nt_status) 0xC0000038)
+#define NT_STATUS_DEVICE_BUSY ((nt_status) 0x80000011)
+#define NT_STATUS_DEVICE_CONFIGURATION_ERROR ((nt_status) 0xC0000182)
+#define NT_STATUS_DEVICE_DATA_ERROR ((nt_status) 0xC000009C)
+#define NT_STATUS_DEVICE_DOES_NOT_EXIST ((nt_status) 0xC00000C0)
+#define NT_STATUS_DEVICE_DOOR_OPEN ((nt_status) 0x80000289)
+#define NT_STATUS_DEVICE_ENUMERATION_ERROR ((nt_status) 0xC0000366)
+#define NT_STATUS_DEVICE_NOT_CONNECTED ((nt_status) 0xC000009D)
+#define NT_STATUS_DEVICE_NOT_PARTITIONED ((nt_status) 0xC0000174)
+#define NT_STATUS_DEVICE_NOT_READY ((nt_status) 0xC00000A3)
+#define NT_STATUS_DEVICE_OFF_LINE ((nt_status) 0x80000010)
+#define NT_STATUS_DEVICE_PAPER_EMPTY ((nt_status) 0x8000000E)
+#define NT_STATUS_DEVICE_POWERED_OFF ((nt_status) 0x8000000F)
+#define NT_STATUS_DEVICE_PROTOCOL_ERROR ((nt_status) 0xC0000186)
+#define NT_STATUS_DEVICE_REMOVED ((nt_status) 0xC00002B6)
+#define NT_STATUS_DEVICE_REQUIRES_CLEANING ((nt_status) 0x80000288)
+#define NT_STATUS_DFS_EXIT_PATH_FOUND ((nt_status) 0xC000009B)
+#define NT_STATUS_DFS_UNAVAILABLE ((nt_status) 0xC000026D)
+#define NT_STATUS_DIRECTORY_IS_A_REPARSE_POINT ((nt_status) 0xC0000281)
+#define NT_STATUS_DIRECTORY_NOT_EMPTY ((nt_status) 0xC0000101)
+#define NT_STATUS_DIRECTORY_NOT_RM ((nt_status) 0xC0190008)
+#define NT_STATUS_DIRECTORY_SERVICE_REQUIRED ((nt_status) 0xC00002B1)
+#define NT_STATUS_DISK_CORRUPT_ERROR ((nt_status) 0xC0000032)
+#define NT_STATUS_DISK_FULL ((nt_status) 0xC000007F)
+#define NT_STATUS_DISK_OPERATION_FAILED ((nt_status) 0xC000016A)
+#define NT_STATUS_DISK_QUOTA_EXCEEDED ((nt_status) 0xC0000802)
+#define NT_STATUS_DISK_RECALIBRATE_FAILED ((nt_status) 0xC0000169)
+#define NT_STATUS_DISK_REPAIR_DISABLED ((nt_status) 0xC0000800)
+#define NT_STATUS_DISK_RESET_FAILED ((nt_status) 0xC000016B)
+#define NT_STATUS_DLL_INIT_FAILED ((nt_status) 0xC0000142)
+#define NT_STATUS_DLL_INIT_FAILED_LOGOFF ((nt_status) 0xC000026B)
+#define NT_STATUS_DLL_MIGHT_BE_INCOMPATIBLE ((nt_status) 0x8000002C)
+#define NT_STATUS_DLL_MIGHT_BE_INSECURE ((nt_status) 0x8000002B)
+#define NT_STATUS_DLL_NOT_FOUND ((nt_status) 0xC0000135)
+#define NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND ((nt_status) 0xC0000233)
+#define NT_STATUS_DOMAIN_CTRLR_CONFIG_ERROR ((nt_status) 0xC000015E)
+#define NT_STATUS_DOMAIN_EXISTS ((nt_status) 0xC00000E0)
+#define NT_STATUS_DOMAIN_LIMIT_EXCEEDED ((nt_status) 0xC00000E1)
+#define NT_STATUS_DOMAIN_TRUST_INCONSISTENT ((nt_status) 0xC000019B)
+#define NT_STATUS_DOWNGRADE_DETECTED ((nt_status) 0xC0000388)
+#define NT_STATUS_DRIVERS_LEAKING_LOCKED_PAGES ((nt_status) 0x4000002D)
+#define NT_STATUS_DRIVER_BLOCKED ((nt_status) 0xC000036C)
+#define NT_STATUS_DRIVER_BLOCKED_CRITICAL ((nt_status) 0xC000036B)
+#define NT_STATUS_DRIVER_CANCEL_TIMEOUT ((nt_status) 0xC000021E)
+#define NT_STATUS_DRIVER_DATABASE_ERROR ((nt_status) 0xC000036D)
+#define NT_STATUS_DRIVER_ENTRYPOINT_NOT_FOUND ((nt_status) 0xC0000263)
+#define NT_STATUS_DRIVER_FAILED_PRIOR_UNLOAD ((nt_status) 0xC000038E)
+#define NT_STATUS_DRIVER_FAILED_SLEEP ((nt_status) 0xC00002C2)
+#define NT_STATUS_DRIVER_INTERNAL_ERROR ((nt_status) 0xC0000183)
+#define NT_STATUS_DRIVER_ORDINAL_NOT_FOUND ((nt_status) 0xC0000262)
+#define NT_STATUS_DRIVER_PROCESS_TERMINATED ((nt_status) 0xC0000450)
+#define NT_STATUS_DRIVER_UNABLE_TO_LOAD ((nt_status) 0xC000026C)
+#define NT_STATUS_DS_ADMIN_LIMIT_EXCEEDED ((nt_status) 0xC00002C1)
+#define NT_STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER ((nt_status) 0xC0000358)
+#define NT_STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS ((nt_status) 0xC00002A4)
+#define NT_STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED ((nt_status) 0xC00002A3)
+#define NT_STATUS_DS_BUSY ((nt_status) 0xC00002A5)
+#define NT_STATUS_DS_CANT_MOD_OBJ_CLASS ((nt_status) 0xC00002AE)
+#define NT_STATUS_DS_CANT_MOD_PRIMARYGROUPID ((nt_status) 0xC00002D0)
+#define NT_STATUS_DS_CANT_ON_NON_LEAF ((nt_status) 0xC00002AC)
+#define NT_STATUS_DS_CANT_ON_RDN ((nt_status) 0xC00002AD)
+#define NT_STATUS_DS_CANT_START ((nt_status) 0xC00002E1)
+#define NT_STATUS_DS_CROSS_DOM_MOVE_FAILED ((nt_status) 0xC00002AF)
+#define NT_STATUS_DS_DOMAIN_NAME_EXISTS_IN_FOREST ((nt_status) 0xC000041A)
+#define NT_STATUS_DS_DOMAIN_RENAME_IN_PROGRESS ((nt_status) 0xC0000801)
+#define NT_STATUS_DS_DUPLICATE_ID_FOUND ((nt_status) 0xC0000405)
+#define NT_STATUS_DS_FLAT_NAME_EXISTS_IN_FOREST ((nt_status) 0xC000041B)
+#define NT_STATUS_DS_GC_NOT_AVAILABLE ((nt_status) 0xC00002B0)
+#define NT_STATUS_DS_GC_REQUIRED ((nt_status) 0xC00002E4)
+#define NT_STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER ((nt_status) 0xC00002DA)
+#define NT_STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER ((nt_status) 0xC00002D7)
+#define NT_STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER ((nt_status) 0xC00002D8)
+#define NT_STATUS_DS_GROUP_CONVERSION_ERROR ((nt_status) 0xC0000406)
+#define NT_STATUS_DS_HAVE_PRIMARY_MEMBERS ((nt_status) 0xC00002DC)
+#define NT_STATUS_DS_INCORRECT_ROLE_OWNER ((nt_status) 0xC00002A9)
+#define NT_STATUS_DS_INIT_FAILURE ((nt_status) 0xC00002E2)
+#define NT_STATUS_DS_INIT_FAILURE_CONSOLE ((nt_status) 0xC00002EC)
+#define NT_STATUS_DS_INVALID_ATTRIBUTE_SYNTAX ((nt_status) 0xC00002A2)
+#define NT_STATUS_DS_INVALID_GROUP_TYPE ((nt_status) 0xC00002D4)
+#define NT_STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER ((nt_status) 0xC00002DB)
+#define NT_STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY ((nt_status) 0xC00002E5)
+#define NT_STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED ((nt_status) 0xC00002E7)
+#define NT_STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY ((nt_status) 0x00000121)
+#define NT_STATUS_DS_NAME_NOT_UNIQUE ((nt_status) 0xC0000404)
+#define NT_STATUS_DS_NO_ATTRIBUTE_OR_VALUE ((nt_status) 0xC00002A1)
+#define NT_STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS ((nt_status) 0xC00002E6)
+#define NT_STATUS_DS_NO_MORE_RIDS ((nt_status) 0xC00002A8)
+#define NT_STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN ((nt_status) 0xC00002D5)
+#define NT_STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN ((nt_status) 0xC00002D6)
+#define NT_STATUS_DS_NO_RIDS_ALLOCATED ((nt_status) 0xC00002A7)
+#define NT_STATUS_DS_OBJ_CLASS_VIOLATION ((nt_status) 0xC00002AB)
+#define NT_STATUS_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS ((nt_status) 0xC000A087)
+#define NT_STATUS_DS_OID_NOT_FOUND ((nt_status) 0xC000A088)
+#define NT_STATUS_DS_RIDMGR_INIT_ERROR ((nt_status) 0xC00002AA)
+#define NT_STATUS_DS_SAM_INIT_FAILURE ((nt_status) 0xC00002CB)
+#define NT_STATUS_DS_SAM_INIT_FAILURE_CONSOLE ((nt_status) 0xC00002ED)
+#define NT_STATUS_DS_SENSITIVE_GROUP_VIOLATION ((nt_status) 0xC00002CD)
+#define NT_STATUS_DS_SHUTTING_DOWN ((nt_status) 0x40000370)
+#define NT_STATUS_DS_SRC_SID_EXISTS_IN_FOREST ((nt_status) 0xC0000419)
+#define NT_STATUS_DS_UNAVAILABLE ((nt_status) 0xC00002A6)
+#define NT_STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER ((nt_status) 0xC00002D9)
+#define NT_STATUS_DS_VERSION_CHECK_FAILURE ((nt_status) 0xC0000355)
+#define NT_STATUS_DUPLICATE_NAME ((nt_status) 0xC00000BD)
+#define NT_STATUS_DUPLICATE_OBJECTID ((nt_status) 0xC000022A)
+#define NT_STATUS_EAS_NOT_SUPPORTED ((nt_status) 0xC000004F)
+#define NT_STATUS_EA_CORRUPT_ERROR ((nt_status) 0xC0000053)
+#define NT_STATUS_EA_LIST_INCONSISTENT ((nt_status) 0x80000014)
+#define NT_STATUS_EA_TOO_LARGE ((nt_status) 0xC0000050)
+#define NT_STATUS_EFS_ALG_BLOB_TOO_BIG ((nt_status) 0xC0000352)
+#define NT_STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION ((nt_status) 0xC019003E)
+#define NT_STATUS_ELEVATION_REQUIRED ((nt_status) 0xC000042C)
+#define NT_STATUS_ENCOUNTERED_WRITE_IN_PROGRESS ((nt_status) 0xC0000433)
+#define NT_STATUS_ENCRYPTION_FAILED ((nt_status) 0xC000028A)
+#define NT_STATUS_END_OF_FILE ((nt_status) 0xC0000011)
+#define NT_STATUS_END_OF_MEDIA ((nt_status) 0x8000001E)
+#define NT_STATUS_ENLISTMENT_NOT_FOUND ((nt_status) 0xC0190050)
+#define NT_STATUS_ENLISTMENT_NOT_SUPERIOR ((nt_status) 0xC0190033)
+#define NT_STATUS_ENTRYPOINT_NOT_FOUND ((nt_status) 0xC0000139)
+#define NT_STATUS_EOM_OVERFLOW ((nt_status) 0xC0000177)
+#define NT_STATUS_EVALUATION_EXPIRATION ((nt_status) 0xC0000268)
+#define NT_STATUS_EVENTLOG_CANT_START ((nt_status) 0xC000018F)
+#define NT_STATUS_EVENTLOG_FILE_CHANGED ((nt_status) 0xC0000197)
+#define NT_STATUS_EVENTLOG_FILE_CORRUPT ((nt_status) 0xC000018E)
+#define NT_STATUS_EVENT_DONE ((nt_status) 0x40000012)
+#define NT_STATUS_EVENT_PENDING ((nt_status) 0x40000013)
+#define NT_STATUS_EXPIRED_HANDLE ((nt_status) 0xC0190060)
+#define NT_STATUS_EXTRANEOUS_INFORMATION ((nt_status) 0x80000017)
+#define NT_STATUS_FAILED_DRIVER_ENTRY ((nt_status) 0xC0000365)
+#define NT_STATUS_FAILED_STACK_SWITCH ((nt_status) 0xC0000373)
+#define NT_STATUS_FAIL_CHECK ((nt_status) 0xC0000229)
+#define NT_STATUS_FAIL_FAST_EXCEPTION ((nt_status) 0xC0000602)
+#define NT_STATUS_FATAL_APP_EXIT ((nt_status) 0x40000015)
+#define NT_STATUS_FILEMARK_DETECTED ((nt_status) 0x8000001B)
+#define NT_STATUS_FILES_OPEN ((nt_status) 0xC0000107)
+#define NT_STATUS_FILE_CHECKED_OUT ((nt_status) 0xC0000901)
+#define NT_STATUS_FILE_CLOSED ((nt_status) 0xC0000128)
+#define NT_STATUS_FILE_CORRUPT_ERROR ((nt_status) 0xC0000102)
+#define NT_STATUS_FILE_DELETED ((nt_status) 0xC0000123)
+#define NT_STATUS_FILE_ENCRYPTED ((nt_status) 0xC0000293)
+#define NT_STATUS_FILE_FORCED_CLOSED ((nt_status) 0xC00000B6)
+#define NT_STATUS_FILE_IDENTITY_NOT_PERSISTENT ((nt_status) 0xC0190036)
+#define NT_STATUS_FILE_INVALID ((nt_status) 0xC0000098)
+#define NT_STATUS_FILE_IS_A_DIRECTORY ((nt_status) 0xC00000BA)
+#define NT_STATUS_FILE_IS_OFFLINE ((nt_status) 0xC0000267)
+#define NT_STATUS_FILE_LOCKED_WITH_ONLY_READERS ((nt_status) 0x0000012A)
+#define NT_STATUS_FILE_LOCKED_WITH_WRITERS ((nt_status) 0x0000012B)
+#define NT_STATUS_FILE_LOCK_CONFLICT ((nt_status) 0xC0000054)
+#define NT_STATUS_FILE_NOT_AVAILABLE ((nt_status) 0xC0000467)
+#define NT_STATUS_FILE_NOT_ENCRYPTED ((nt_status) 0xC0000291)
+#define NT_STATUS_FILE_RENAMED ((nt_status) 0xC00000D5)
+#define NT_STATUS_FILE_SYSTEM_LIMITATION ((nt_status) 0xC0000427)
+#define NT_STATUS_FILE_TOO_LARGE ((nt_status) 0xC0000904)
+#define NT_STATUS_FIRMWARE_UPDATED ((nt_status) 0x4000002C)
+#define NT_STATUS_FLOATED_SECTION ((nt_status) 0xC019004B)
+#define NT_STATUS_FLOAT_DENORMAL_OPERAND ((nt_status) 0xC000008D)
+#define NT_STATUS_FLOAT_DIVIDE_BY_ZERO ((nt_status) 0xC000008E)
+#define NT_STATUS_FLOAT_INEXACT_RESULT ((nt_status) 0xC000008F)
+#define NT_STATUS_FLOAT_INVALID_OPERATION ((nt_status) 0xC0000090)
+#define NT_STATUS_FLOAT_MULTIPLE_FAULTS ((nt_status) 0xC00002B4)
+#define NT_STATUS_FLOAT_MULTIPLE_TRAPS ((nt_status) 0xC00002B5)
+#define NT_STATUS_FLOAT_OVERFLOW ((nt_status) 0xC0000091)
+#define NT_STATUS_FLOAT_STACK_CHECK ((nt_status) 0xC0000092)
+#define NT_STATUS_FLOAT_UNDERFLOW ((nt_status) 0xC0000093)
+#define NT_STATUS_FLOPPY_BAD_REGISTERS ((nt_status) 0xC0000168)
+#define NT_STATUS_FLOPPY_ID_MARK_NOT_FOUND ((nt_status) 0xC0000165)
+#define NT_STATUS_FLOPPY_UNKNOWN_ERROR ((nt_status) 0xC0000167)
+#define NT_STATUS_FLOPPY_VOLUME ((nt_status) 0xC0000164)
+#define NT_STATUS_FLOPPY_WRONG_CYLINDER ((nt_status) 0xC0000166)
+#define NT_STATUS_FLT_ALREADY_ENLISTED ((nt_status) 0xC01C001B)
+#define NT_STATUS_FLT_BUFFER_TOO_SMALL ((nt_status) 0x801C0001)
+#define NT_STATUS_FLT_CBDQ_DISABLED ((nt_status) 0xC01C000E)
+#define NT_STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND ((nt_status) 0xC01C0016)
+#define NT_STATUS_FLT_CONTEXT_ALREADY_DEFINED ((nt_status) 0xC01C0002)
+#define NT_STATUS_FLT_CONTEXT_ALREADY_LINKED ((nt_status) 0xC01C001C)
+#define NT_STATUS_FLT_DELETING_OBJECT ((nt_status) 0xC01C000B)
+#define NT_STATUS_FLT_DISALLOW_FAST_IO ((nt_status) 0xC01C0004)
+#define NT_STATUS_FLT_DO_NOT_ATTACH ((nt_status) 0xC01C000F)
+#define NT_STATUS_FLT_DO_NOT_DETACH ((nt_status) 0xC01C0010)
+#define NT_STATUS_FLT_DUPLICATE_ENTRY ((nt_status) 0xC01C000D)
+#define NT_STATUS_FLT_FILTER_NOT_FOUND ((nt_status) 0xC01C0013)
+#define NT_STATUS_FLT_FILTER_NOT_READY ((nt_status) 0xC01C0008)
+#define NT_STATUS_FLT_INSTANCE_ALTITUDE_COLLISION ((nt_status) 0xC01C0011)
+#define NT_STATUS_FLT_INSTANCE_NAME_COLLISION ((nt_status) 0xC01C0012)
+#define NT_STATUS_FLT_INSTANCE_NOT_FOUND ((nt_status) 0xC01C0015)
+#define NT_STATUS_FLT_INTERNAL_ERROR ((nt_status) 0xC01C000A)
+#define NT_STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST ((nt_status) 0xC01C0003)
+#define NT_STATUS_FLT_INVALID_CONTEXT_REGISTRATION ((nt_status) 0xC01C0017)
+#define NT_STATUS_FLT_INVALID_NAME_REQUEST ((nt_status) 0xC01C0005)
+#define NT_STATUS_FLT_IO_COMPLETE ((nt_status) 0x001C0001)
+#define NT_STATUS_FLT_MUST_BE_NONPAGED_POOL ((nt_status) 0xC01C000C)
+#define NT_STATUS_FLT_NAME_CACHE_MISS ((nt_status) 0xC01C0018)
+#define NT_STATUS_FLT_NOT_INITIALIZED ((nt_status) 0xC01C0007)
+#define NT_STATUS_FLT_NOT_SAFE_TO_POST_OPERATION ((nt_status) 0xC01C0006)
+#define NT_STATUS_FLT_NO_DEVICE_OBJECT ((nt_status) 0xC01C0019)
+#define NT_STATUS_FLT_NO_HANDLER_DEFINED ((nt_status) 0xC01C0001)
+#define NT_STATUS_FLT_NO_WAITER_FOR_REPLY ((nt_status) 0xC01C0020)
+#define NT_STATUS_FLT_POST_OPERATION_CLEANUP ((nt_status) 0xC01C0009)
+#define NT_STATUS_FLT_VOLUME_ALREADY_MOUNTED ((nt_status) 0xC01C001A)
+#define NT_STATUS_FLT_VOLUME_NOT_FOUND ((nt_status) 0xC01C0014)
+#define NT_STATUS_FORMS_AUTH_REQUIRED ((nt_status) 0xC0000905)
+#define NT_STATUS_FOUND_OUT_OF_SCOPE ((nt_status) 0xC000022E)
+#define NT_STATUS_FREE_VM_NOT_AT_BASE ((nt_status) 0xC000009F)
+#define NT_STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY ((nt_status) 0x00000126)
+#define NT_STATUS_FS_DRIVER_REQUIRED ((nt_status) 0xC000019C)
+#define NT_STATUS_FT_MISSING_MEMBER ((nt_status) 0xC000015F)
+#define NT_STATUS_FT_ORPHANING ((nt_status) 0xC000016D)
+#define NT_STATUS_FT_READ_RECOVERY_FROM_BACKUP ((nt_status) 0x4000000A)
+#define NT_STATUS_FT_WRITE_RECOVERY ((nt_status) 0x4000000B)
+#define NT_STATUS_FULLSCREEN_MODE ((nt_status) 0xC0000159)
+#define NT_STATUS_FVE_ACTION_NOT_ALLOWED ((nt_status) 0xC0210009)
+#define NT_STATUS_FVE_AUTH_INVALID_APPLICATION ((nt_status) 0xC021001B)
+#define NT_STATUS_FVE_AUTH_INVALID_CONFIG ((nt_status) 0xC021001C)
+#define NT_STATUS_FVE_BAD_DATA ((nt_status) 0xC021000A)
+#define NT_STATUS_FVE_BAD_INFORMATION ((nt_status) 0xC0210002)
+#define NT_STATUS_FVE_BAD_METADATA_POINTER ((nt_status) 0xC021001F)
+#define NT_STATUS_FVE_CONV_READ_ERROR ((nt_status) 0xC021000D)
+#define NT_STATUS_FVE_CONV_RECOVERY_FAILED ((nt_status) 0xC0210028)
+#define NT_STATUS_FVE_CONV_WRITE_ERROR ((nt_status) 0xC021000E)
+#define NT_STATUS_FVE_DEBUGGER_ENABLED ((nt_status) 0xC021001D)
+#define NT_STATUS_FVE_DRY_RUN_FAILED ((nt_status) 0xC021001E)
+#define NT_STATUS_FVE_FAILED_AUTHENTICATION ((nt_status) 0xC0210011)
+#define NT_STATUS_FVE_FAILED_BAD_FS ((nt_status) 0xC0210005)
+#define NT_STATUS_FVE_FAILED_SECTOR_SIZE ((nt_status) 0xC0210010)
+#define NT_STATUS_FVE_FAILED_WRONG_FS ((nt_status) 0xC0210004)
+#define NT_STATUS_FVE_FS_MOUNTED ((nt_status) 0xC0210007)
+#define NT_STATUS_FVE_FS_NOT_EXTENDED ((nt_status) 0xC0210006)
+#define NT_STATUS_FVE_KEYFILE_INVALID ((nt_status) 0xC0210014)
+#define NT_STATUS_FVE_KEYFILE_NOT_FOUND ((nt_status) 0xC0210013)
+#define NT_STATUS_FVE_KEYFILE_NO_VMK ((nt_status) 0xC0210015)
+#define NT_STATUS_FVE_LOCKED_VOLUME ((nt_status) 0xC0210000)
+#define NT_STATUS_FVE_NOT_DATA_VOLUME ((nt_status) 0xC021000C)
+#define NT_STATUS_FVE_NOT_ENCRYPTED ((nt_status) 0xC0210001)
+#define NT_STATUS_FVE_NOT_OS_VOLUME ((nt_status) 0xC0210012)
+#define NT_STATUS_FVE_NO_FEATURE_LICENSE ((nt_status) 0xC0210026)
+#define NT_STATUS_FVE_NO_LICENSE ((nt_status) 0xC0210008)
+#define NT_STATUS_FVE_OLD_METADATA_COPY ((nt_status) 0xC0210020)
+#define NT_STATUS_FVE_OVERLAPPED_UPDATE ((nt_status) 0xC021000F)
+#define NT_STATUS_FVE_PARTIAL_METADATA ((nt_status) 0x80210001)
+#define NT_STATUS_FVE_PIN_INVALID ((nt_status) 0xC021001A)
+#define NT_STATUS_FVE_POLICY_USER_DISABLE_RDV_NOT_ALLOWED ((nt_status) 0xC0210027)
+#define NT_STATUS_FVE_RAW_ACCESS ((nt_status) 0xC0210022)
+#define NT_STATUS_FVE_RAW_BLOCKED ((nt_status) 0xC0210023)
+#define NT_STATUS_FVE_REBOOT_REQUIRED ((nt_status) 0xC0210021)
+#define NT_STATUS_FVE_TOO_SMALL ((nt_status) 0xC0210003)
+#define NT_STATUS_FVE_TPM_DISABLED ((nt_status) 0xC0210016)
+#define NT_STATUS_FVE_TPM_INVALID_PCR ((nt_status) 0xC0210018)
+#define NT_STATUS_FVE_TPM_NO_VMK ((nt_status) 0xC0210019)
+#define NT_STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO ((nt_status) 0xC0210017)
+#define NT_STATUS_FVE_TRANSIENT_STATE ((nt_status) 0x80210002)
+#define NT_STATUS_FVE_VIRTUALIZED_SPACE_TOO_BIG ((nt_status) 0xC0210029)
+#define NT_STATUS_FVE_VOLUME_NOT_BOUND ((nt_status) 0xC021000B)
+#define NT_STATUS_FVE_VOLUME_TOO_SMALL ((nt_status) 0xC0210030)
+#define NT_STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER ((nt_status) 0xC022002C)
+#define NT_STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER ((nt_status) 0xC022002D)
+#define NT_STATUS_FWP_ALREADY_EXISTS ((nt_status) 0xC0220009)
+#define NT_STATUS_FWP_BUILTIN_OBJECT ((nt_status) 0xC0220017)
+#define NT_STATUS_FWP_CALLOUT_NOTIFICATION_FAILED ((nt_status) 0xC0220037)
+#define NT_STATUS_FWP_CALLOUT_NOT_FOUND ((nt_status) 0xC0220001)
+#define NT_STATUS_FWP_CANNOT_PEND ((nt_status) 0xC0220103)
+#define NT_STATUS_FWP_CONDITION_NOT_FOUND ((nt_status) 0xC0220002)
+#define NT_STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT ((nt_status) 0xC022002F)
+#define NT_STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER ((nt_status) 0xC022002E)
+#define NT_STATUS_FWP_DUPLICATE_AUTH_METHOD ((nt_status) 0xC022003C)
+#define NT_STATUS_FWP_DUPLICATE_CONDITION ((nt_status) 0xC022002A)
+#define NT_STATUS_FWP_DUPLICATE_KEYMOD ((nt_status) 0xC022002B)
+#define NT_STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS ((nt_status) 0xC022000B)
+#define NT_STATUS_FWP_EM_NOT_SUPPORTED ((nt_status) 0xC0220032)
+#define NT_STATUS_FWP_FILTER_NOT_FOUND ((nt_status) 0xC0220003)
+#define NT_STATUS_FWP_INCOMPATIBLE_AUTH_CONFIG ((nt_status) 0xC0220038)
+#define NT_STATUS_FWP_INCOMPATIBLE_AUTH_METHOD ((nt_status) 0xC0220030)
+#define NT_STATUS_FWP_INCOMPATIBLE_CIPHER_CONFIG ((nt_status) 0xC0220039)
+#define NT_STATUS_FWP_INCOMPATIBLE_DH_GROUP ((nt_status) 0xC0220031)
+#define NT_STATUS_FWP_INCOMPATIBLE_LAYER ((nt_status) 0xC0220014)
+#define NT_STATUS_FWP_INCOMPATIBLE_SA_STATE ((nt_status) 0xC022001B)
+#define NT_STATUS_FWP_INCOMPATIBLE_TXN ((nt_status) 0xC0220011)
+#define NT_STATUS_FWP_INJECT_HANDLE_CLOSING ((nt_status) 0xC0220101)
+#define NT_STATUS_FWP_INJECT_HANDLE_STALE ((nt_status) 0xC0220102)
+#define NT_STATUS_FWP_INVALID_ACTION_TYPE ((nt_status) 0xC0220024)
+#define NT_STATUS_FWP_INVALID_ENUMERATOR ((nt_status) 0xC022001D)
+#define NT_STATUS_FWP_INVALID_FLAGS ((nt_status) 0xC022001E)
+#define NT_STATUS_FWP_INVALID_INTERVAL ((nt_status) 0xC0220021)
+#define NT_STATUS_FWP_INVALID_NET_MASK ((nt_status) 0xC022001F)
+#define NT_STATUS_FWP_INVALID_PARAMETER ((nt_status) 0xC0220035)
+#define NT_STATUS_FWP_INVALID_RANGE ((nt_status) 0xC0220020)
+#define NT_STATUS_FWP_INVALID_WEIGHT ((nt_status) 0xC0220025)
+#define NT_STATUS_FWP_IN_USE ((nt_status) 0xC022000A)
+#define NT_STATUS_FWP_KM_CLIENTS_ONLY ((nt_status) 0xC0220015)
+#define NT_STATUS_FWP_LAYER_NOT_FOUND ((nt_status) 0xC0220004)
+#define NT_STATUS_FWP_LIFETIME_MISMATCH ((nt_status) 0xC0220016)
+#define NT_STATUS_FWP_MATCH_TYPE_MISMATCH ((nt_status) 0xC0220026)
+#define NT_STATUS_FWP_NET_EVENTS_DISABLED ((nt_status) 0xC0220013)
+#define NT_STATUS_FWP_NEVER_MATCH ((nt_status) 0xC0220033)
+#define NT_STATUS_FWP_NOTIFICATION_DROPPED ((nt_status) 0xC0220019)
+#define NT_STATUS_FWP_NOT_FOUND ((nt_status) 0xC0220008)
+#define NT_STATUS_FWP_NO_TXN_IN_PROGRESS ((nt_status) 0xC022000D)
+#define NT_STATUS_FWP_NULL_DISPLAY_NAME ((nt_status) 0xC0220023)
+#define NT_STATUS_FWP_NULL_POINTER ((nt_status) 0xC022001C)
+#define NT_STATUS_FWP_OUT_OF_BOUNDS ((nt_status) 0xC0220028)
+#define NT_STATUS_FWP_PROVIDER_CONTEXT_MISMATCH ((nt_status) 0xC0220034)
+#define NT_STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND ((nt_status) 0xC0220006)
+#define NT_STATUS_FWP_PROVIDER_NOT_FOUND ((nt_status) 0xC0220005)
+#define NT_STATUS_FWP_RESERVED ((nt_status) 0xC0220029)
+#define NT_STATUS_FWP_SESSION_ABORTED ((nt_status) 0xC0220010)
+#define NT_STATUS_FWP_SUBLAYER_NOT_FOUND ((nt_status) 0xC0220007)
+#define NT_STATUS_FWP_TCPIP_NOT_READY ((nt_status) 0xC0220100)
+#define NT_STATUS_FWP_TIMEOUT ((nt_status) 0xC0220012)
+#define NT_STATUS_FWP_TOO_MANY_BOOTTIME_FILTERS ((nt_status) 0xC0220018)
+#define NT_STATUS_FWP_TOO_MANY_CALLOUTS ((nt_status) 0xC0220018)
+#define NT_STATUS_FWP_TOO_MANY_SUBLAYERS ((nt_status) 0xC0220036)
+#define NT_STATUS_FWP_TRAFFIC_MISMATCH ((nt_status) 0xC022001A)
+#define NT_STATUS_FWP_TXN_ABORTED ((nt_status) 0xC022000F)
+#define NT_STATUS_FWP_TXN_IN_PROGRESS ((nt_status) 0xC022000E)
+#define NT_STATUS_FWP_TYPE_MISMATCH ((nt_status) 0xC0220027)
+#define NT_STATUS_FWP_WRONG_SESSION ((nt_status) 0xC022000C)
+#define NT_STATUS_FWP_ZERO_LENGTH_ARRAY ((nt_status) 0xC0220022)
+#define NT_STATUS_GENERIC_COMMAND_FAILED ((nt_status) 0xC0150026)
+#define NT_STATUS_GENERIC_NOT_MAPPED ((nt_status) 0xC00000E6)
+#define NT_STATUS_GRACEFUL_DISCONNECT ((nt_status) 0xC0000237)
+#define NT_STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED ((nt_status) 0xC01E043B)
+#define NT_STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY ((nt_status) 0xC01E0433)
+#define NT_STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE ((nt_status) 0xC01E0328)
+#define NT_STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET ((nt_status) 0xC01E0329)
+#define NT_STATUS_GRAPHICS_ADAPTER_WAS_RESET ((nt_status) 0xC01E0003)
+#define NT_STATUS_GRAPHICS_ALLOCATION_BUSY ((nt_status) 0xC01E0102)
+#define NT_STATUS_GRAPHICS_ALLOCATION_CLOSED ((nt_status) 0xC01E0112)
+#define NT_STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST ((nt_status) 0xC01E0116)
+#define NT_STATUS_GRAPHICS_ALLOCATION_INVALID ((nt_status) 0xC01E0106)
+#define NT_STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION ((nt_status) 0xC01E035A)
+#define NT_STATUS_GRAPHICS_CANNOTCOLORCONVERT ((nt_status) 0xC01E0008)
+#define NT_STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN ((nt_status) 0xC01E0343)
+#define NT_STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION ((nt_status) 0xC01E0109)
+#define NT_STATUS_GRAPHICS_CANT_LOCK_MEMORY ((nt_status) 0xC01E0101)
+#define NT_STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION ((nt_status) 0xC01E0111)
+#define NT_STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED ((nt_status) 0xC01E0432)
+#define NT_STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON ((nt_status) 0xC01E0435)
+#define NT_STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED ((nt_status) 0xC01E0434)
+#define NT_STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED ((nt_status) 0xC01E0401)
+#define NT_STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET ((nt_status) 0xC01E035C)
+#define NT_STATUS_GRAPHICS_COPP_NOT_SUPPORTED ((nt_status) 0xC01E0501)
+#define NT_STATUS_GRAPHICS_DATASET_IS_EMPTY ((nt_status) 0x401E034B)
+#define NT_STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING ((nt_status) 0xC01E0587)
+#define NT_STATUS_GRAPHICS_DDCCI_INVALID_DATA ((nt_status) 0xC01E0585)
+#define NT_STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM ((nt_status) 0xC01E058B)
+#define NT_STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND ((nt_status) 0xC01E0589)
+#define NT_STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH ((nt_status) 0xC01E058A)
+#define NT_STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE ((nt_status) 0xC01E0586)
+#define NT_STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED ((nt_status) 0xC01E0584)
+#define NT_STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP ((nt_status) 0xC01E05E2)
+#define NT_STATUS_GRAPHICS_DRIVER_MISMATCH ((nt_status) 0x401E0117)
+#define NT_STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION ((nt_status) 0xC01E0325)
+#define NT_STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET ((nt_status) 0xC01E031F)
+#define NT_STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET ((nt_status) 0xC01E031D)
+#define NT_STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED ((nt_status) 0xC01E0348)
+#define NT_STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE ((nt_status) 0xC01E0200)
+#define NT_STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST ((nt_status) 0xC01E0581)
+#define NT_STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA ((nt_status) 0xC01E0583)
+#define NT_STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA ((nt_status) 0xC01E0582)
+#define NT_STATUS_GRAPHICS_I2C_NOT_SUPPORTED ((nt_status) 0xC01E0580)
+#define NT_STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT ((nt_status) 0xC01E0355)
+#define NT_STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE ((nt_status) 0xC01E0436)
+#define NT_STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER ((nt_status) 0xC01E0001)
+#define NT_STATUS_GRAPHICS_INTERNAL_ERROR ((nt_status) 0xC01E05E7)
+#define NT_STATUS_GRAPHICS_INVALID_ACTIVE_REGION ((nt_status) 0xC01E030B)
+#define NT_STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE ((nt_status) 0xC01E0114)
+#define NT_STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE ((nt_status) 0xC01E0113)
+#define NT_STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE ((nt_status) 0xC01E0110)
+#define NT_STATUS_GRAPHICS_INVALID_CLIENT_TYPE ((nt_status) 0xC01E035B)
+#define NT_STATUS_GRAPHICS_INVALID_COLORBASIS ((nt_status) 0xC01E033E)
+#define NT_STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE ((nt_status) 0xC01E034F)
+#define NT_STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER ((nt_status) 0xC01E0002)
+#define NT_STATUS_GRAPHICS_INVALID_DRIVER_MODEL ((nt_status) 0xC01E0004)
+#define NT_STATUS_GRAPHICS_INVALID_FREQUENCY ((nt_status) 0xC01E030A)
+#define NT_STATUS_GRAPHICS_INVALID_GAMMA_RAMP ((nt_status) 0xC01E0347)
+#define NT_STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM ((nt_status) 0xC01E0356)
+#define NT_STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR ((nt_status) 0xC01E032B)
+#define NT_STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET ((nt_status) 0xC01E032A)
+#define NT_STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN ((nt_status) 0xC01E0357)
+#define NT_STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE ((nt_status) 0xC01E031C)
+#define NT_STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET ((nt_status) 0xC01E031B)
+#define NT_STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT ((nt_status) 0xC01E0358)
+#define NT_STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET ((nt_status) 0xC01E0321)
+#define NT_STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE ((nt_status) 0xC01E0322)
+#define NT_STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION ((nt_status) 0xC01E0345)
+#define NT_STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE ((nt_status) 0xC01E034E)
+#define NT_STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL ((nt_status) 0xC01E0344)
+#define NT_STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE ((nt_status) 0xC01E058C)
+#define NT_STATUS_GRAPHICS_INVALID_PIXELFORMAT ((nt_status) 0xC01E033D)
+#define NT_STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE ((nt_status) 0xC01E033F)
+#define NT_STATUS_GRAPHICS_INVALID_POINTER ((nt_status) 0xC01E05E4)
+#define NT_STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE ((nt_status) 0xC01E033A)
+#define NT_STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING ((nt_status) 0xC01E0352)
+#define NT_STATUS_GRAPHICS_INVALID_STRIDE ((nt_status) 0xC01E033C)
+#define NT_STATUS_GRAPHICS_INVALID_TOTAL_REGION ((nt_status) 0xC01E030C)
+#define NT_STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET ((nt_status) 0xC01E0315)
+#define NT_STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET ((nt_status) 0xC01E0316)
+#define NT_STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE ((nt_status) 0xC01E0304)
+#define NT_STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE ((nt_status) 0xC01E0310)
+#define NT_STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET ((nt_status) 0xC01E0305)
+#define NT_STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE ((nt_status) 0xC01E0311)
+#define NT_STATUS_GRAPHICS_INVALID_VIDPN ((nt_status) 0xC01E0303)
+#define NT_STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH ((nt_status) 0xC01E0319)
+#define NT_STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET ((nt_status) 0xC01E0308)
+#define NT_STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET ((nt_status) 0xC01E0309)
+#define NT_STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE ((nt_status) 0xC01E032F)
+#define NT_STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY ((nt_status) 0xC01E0300)
+#define NT_STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON ((nt_status) 0xC01E034D)
+#define NT_STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE ((nt_status) 0xC01E033B)
+#define NT_STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED ((nt_status) 0xC01E0431)
+#define NT_STATUS_GRAPHICS_LEADLINK_START_DEFERRED ((nt_status) 0x401E0437)
+#define NT_STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED ((nt_status) 0xC01E0359)
+#define NT_STATUS_GRAPHICS_MCA_INTERNAL_ERROR ((nt_status) 0xC01E0588)
+#define NT_STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED ((nt_status) 0xC01E05E3)
+#define NT_STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET ((nt_status) 0xC01E0314)
+#define NT_STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE ((nt_status) 0xC01E0324)
+#define NT_STATUS_GRAPHICS_MODE_NOT_IN_MODESET ((nt_status) 0xC01E034A)
+#define NT_STATUS_GRAPHICS_MODE_NOT_PINNED ((nt_status) 0x401E0307)
+#define NT_STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET ((nt_status) 0xC01E032D)
+#define NT_STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE ((nt_status) 0xC01E032E)
+#define NT_STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET ((nt_status) 0xC01E032C)
+#define NT_STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER ((nt_status) 0xC01E0334)
+#define NT_STATUS_GRAPHICS_MONITOR_NOT_CONNECTED ((nt_status) 0xC01E0338)
+#define NT_STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS ((nt_status) 0xC01E058D)
+#define NT_STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED ((nt_status) 0xC01E0349)
+#define NT_STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER ((nt_status) 0xC01E0430)
+#define NT_STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER ((nt_status) 0xC01E0000)
+#define NT_STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER ((nt_status) 0xC01E0438)
+#define NT_STATUS_GRAPHICS_NO_ACTIVE_VIDPN ((nt_status) 0xC01E0336)
+#define NT_STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS ((nt_status) 0xC01E0354)
+#define NT_STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET ((nt_status) 0xC01E0333)
+#define NT_STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME ((nt_status) 0xC01E05E1)
+#define NT_STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT ((nt_status) 0xC01E0341)
+#define NT_STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE ((nt_status) 0xC01E05E5)
+#define NT_STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET ((nt_status) 0x401E034C)
+#define NT_STATUS_GRAPHICS_NO_PREFERRED_MODE ((nt_status) 0x401E031E)
+#define NT_STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN ((nt_status) 0xC01E0323)
+#define NT_STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY ((nt_status) 0xC01E031A)
+#define NT_STATUS_GRAPHICS_NO_VIDEO_MEMORY ((nt_status) 0xC01E0100)
+#define NT_STATUS_GRAPHICS_NO_VIDPNMGR ((nt_status) 0xC01E0335)
+#define NT_STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED ((nt_status) 0xC01E05E0)
+#define NT_STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE ((nt_status) 0xC01E0518)
+#define NT_STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR ((nt_status) 0xC01E051E)
+#define NT_STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET ((nt_status) 0xC01E0516)
+#define NT_STATUS_GRAPHICS_OPM_INTERNAL_ERROR ((nt_status) 0xC01E050B)
+#define NT_STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST ((nt_status) 0xC01E0521)
+#define NT_STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS ((nt_status) 0xC01E0503)
+#define NT_STATUS_GRAPHICS_OPM_INVALID_HANDLE ((nt_status) 0xC01E050C)
+#define NT_STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST ((nt_status) 0xC01E051D)
+#define NT_STATUS_GRAPHICS_OPM_INVALID_POINTER ((nt_status) 0xC01E050A)
+#define NT_STATUS_GRAPHICS_OPM_INVALID_SRM ((nt_status) 0xC01E0512)
+#define NT_STATUS_GRAPHICS_OPM_NOT_SUPPORTED ((nt_status) 0xC01E0500)
+#define NT_STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST ((nt_status) 0xC01E0505)
+#define NT_STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP ((nt_status) 0xC01E0514)
+#define NT_STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA ((nt_status) 0xC01E0515)
+#define NT_STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP ((nt_status) 0xC01E0513)
+#define NT_STATUS_GRAPHICS_OPM_PARAMETER_ARRAY_TOO_SMALL ((nt_status) 0xC01E0504)
+#define NT_STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS ((nt_status) 0xC01E051C)
+#define NT_STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS ((nt_status) 0xC01E051F)
+#define NT_STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS ((nt_status) 0xC01E051A)
+#define NT_STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH ((nt_status) 0xC01E0517)
+#define NT_STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS ((nt_status) 0xC01E051B)
+#define NT_STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED ((nt_status) 0xC01E0520)
+#define NT_STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED ((nt_status) 0xC01E050F)
+#define NT_STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED ((nt_status) 0xC01E0510)
+#define NT_STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL ((nt_status) 0xC01E05E6)
+#define NT_STATUS_GRAPHICS_PARTIAL_DATA_POPULATED ((nt_status) 0x401E000A)
+#define NT_STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY ((nt_status) 0xC01E0313)
+#define NT_STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED ((nt_status) 0x401E0351)
+#define NT_STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED ((nt_status) 0xC01E0346)
+#define NT_STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY ((nt_status) 0xC01E0327)
+#define NT_STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET ((nt_status) 0xC01E0312)
+#define NT_STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY ((nt_status) 0x401E0439)
+#define NT_STATUS_GRAPHICS_PRESENT_DENIED ((nt_status) 0xC01E0007)
+#define NT_STATUS_GRAPHICS_PRESENT_MODE_CHANGED ((nt_status) 0xC01E0005)
+#define NT_STATUS_GRAPHICS_PRESENT_OCCLUDED ((nt_status) 0xC01E0006)
+#define NT_STATUS_GRAPHICS_PRESENT_REDIRECTION_DISABLED ((nt_status) 0xC01E000B)
+#define NT_STATUS_GRAPHICS_PRESENT_UNOCCLUDED ((nt_status) 0xC01E000C)
+#define NT_STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP ((nt_status) 0xC01E0507)
+#define NT_STATUS_GRAPHICS_PVP_HFS_FAILED ((nt_status) 0xC01E0511)
+#define NT_STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH ((nt_status) 0xC01E050E)
+#define NT_STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED ((nt_status) 0xC01E0508)
+#define NT_STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME ((nt_status) 0xC01E0506)
+#define NT_STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE ((nt_status) 0xC01E050D)
+#define NT_STATUS_GRAPHICS_RESOURCES_NOT_RELATED ((nt_status) 0xC01E0330)
+#define NT_STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS ((nt_status) 0xC01E05E8)
+#define NT_STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET ((nt_status) 0xC01E0317)
+#define NT_STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE ((nt_status) 0xC01E0331)
+#define NT_STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY ((nt_status) 0xC01E0339)
+#define NT_STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED ((nt_status) 0xC01E0400)
+#define NT_STATUS_GRAPHICS_STALE_MODESET ((nt_status) 0xC01E0320)
+#define NT_STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY ((nt_status) 0xC01E0337)
+#define NT_STATUS_GRAPHICS_START_DEFERRED ((nt_status) 0x401E043A)
+#define NT_STATUS_GRAPHICS_TARGET_ALREADY_IN_SET ((nt_status) 0xC01E0318)
+#define NT_STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE ((nt_status) 0xC01E0332)
+#define NT_STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY ((nt_status) 0xC01E0340)
+#define NT_STATUS_GRAPHICS_TOO_MANY_REFERENCES ((nt_status) 0xC01E0103)
+#define NT_STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED ((nt_status) 0xC01E0353)
+#define NT_STATUS_GRAPHICS_TRY_AGAIN_LATER ((nt_status) 0xC01E0104)
+#define NT_STATUS_GRAPHICS_TRY_AGAIN_NOW ((nt_status) 0xC01E0105)
+#define NT_STATUS_GRAPHICS_UAB_NOT_SUPPORTED ((nt_status) 0xC01E0502)
+#define NT_STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS ((nt_status) 0xC01E0350)
+#define NT_STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS ((nt_status) 0x401E042F)
+#define NT_STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE ((nt_status) 0xC01E0107)
+#define NT_STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED ((nt_status) 0xC01E0108)
+#define NT_STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES ((nt_status) 0xC01E0326)
+#define NT_STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED ((nt_status) 0xC01E0306)
+#define NT_STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE ((nt_status) 0xC01E0342)
+#define NT_STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED ((nt_status) 0xC01E0302)
+#define NT_STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED ((nt_status) 0xC01E0301)
+#define NT_STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE ((nt_status) 0xC01E0115)
+#define NT_STATUS_GROUP_EXISTS ((nt_status) 0xC0000065)
+#define NT_STATUS_GUARD_PAGE_VIOLATION ((nt_status) 0x80000001)
+#define NT_STATUS_GUIDS_EXHAUSTED ((nt_status) 0xC0000083)
+#define NT_STATUS_GUID_SUBSTITUTION_MADE ((nt_status) 0x8000000C)
+#define NT_STATUS_HANDLES_CLOSED ((nt_status) 0x8000000A)
+#define NT_STATUS_HANDLE_NOT_CLOSABLE ((nt_status) 0xC0000235)
+#define NT_STATUS_HANDLE_NO_LONGER_VALID ((nt_status) 0xC0190028)
+#define NT_STATUS_HARDWARE_MEMORY_ERROR ((nt_status) 0xC0000709)
+#define NT_STATUS_HASH_NOT_PRESENT ((nt_status) 0xC000A101)
+#define NT_STATUS_HASH_NOT_SUPPORTED ((nt_status) 0xC000A100)
+#define NT_STATUS_HEAP_CORRUPTION ((nt_status) 0xC0000374)
+#define NT_STATUS_HIBERNATED ((nt_status) 0x4000002A)
+#define NT_STATUS_HIBERNATION_FAILURE ((nt_status) 0xC0000411)
+#define NT_STATUS_HIVE_UNLOADED ((nt_status) 0xC0000425)
+#define NT_STATUS_HMAC_NOT_SUPPORTED ((nt_status) 0xC000A001)
+#define NT_STATUS_HOPLIMIT_EXCEEDED ((nt_status) 0xC000A012)
+#define NT_STATUS_HOST_DOWN ((nt_status) 0xC0000350)
+#define NT_STATUS_HOST_UNREACHABLE ((nt_status) 0xC000023D)
+#define NT_STATUS_HUNG_DISPLAY_DRIVER_THREAD ((nt_status) 0xC0000415)
+#define NT_STATUS_ILLEGAL_CHARACTER ((nt_status) 0xC0000161)
+#define NT_STATUS_ILLEGAL_DLL_RELOCATION ((nt_status) 0xC0000269)
+#define NT_STATUS_ILLEGAL_ELEMENT_ADDRESS ((nt_status) 0xC0000285)
+#define NT_STATUS_ILLEGAL_FLOAT_CONTEXT ((nt_status) 0xC000014A)
+#define NT_STATUS_ILLEGAL_FUNCTION ((nt_status) 0xC00000AF)
+#define NT_STATUS_ILLEGAL_INSTRUCTION ((nt_status) 0xC000001D)
+#define NT_STATUS_ILL_FORMED_PASSWORD ((nt_status) 0xC000006B)
+#define NT_STATUS_ILL_FORMED_SERVICE_ENTRY ((nt_status) 0xC0000160)
+#define NT_STATUS_IMAGE_ALREADY_LOADED ((nt_status) 0xC000010E)
+#define NT_STATUS_IMAGE_ALREADY_LOADED_AS_DLL ((nt_status) 0xC000019D)
+#define NT_STATUS_IMAGE_CERT_REVOKED ((nt_status) 0xC0000603)
+#define NT_STATUS_IMAGE_CHECKSUM_MISMATCH ((nt_status) 0xC0000221)
+#define NT_STATUS_IMAGE_MACHINE_TYPE_MISMATCH ((nt_status) 0x4000000E)
+#define NT_STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE ((nt_status) 0x40000023)
+#define NT_STATUS_IMAGE_MP_UP_MISMATCH ((nt_status) 0xC0000249)
+#define NT_STATUS_IMAGE_NOT_AT_BASE ((nt_status) 0x40000003)
+#define NT_STATUS_IMAGE_SUBSYSTEM_NOT_PRESENT ((nt_status) 0xC00001A3)
+#define NT_STATUS_IMPLEMENTATION_LIMIT ((nt_status) 0xC000042B)
+#define NT_STATUS_INCOMPATIBLE_DRIVER_BLOCKED ((nt_status) 0xC0000424)
+#define NT_STATUS_INCOMPATIBLE_FILE_MAP ((nt_status) 0xC000004D)
+#define NT_STATUS_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING ((nt_status) 0xC000019E)
+#define NT_STATUS_INDOUBT_TRANSACTIONS_EXIST ((nt_status) 0xC019003A)
+#define NT_STATUS_INFO_LENGTH_MISMATCH ((nt_status) 0xC0000004)
+#define NT_STATUS_INSTANCE_NOT_AVAILABLE ((nt_status) 0xC00000AB)
+#define NT_STATUS_INSTRUCTION_MISALIGNMENT ((nt_status) 0xC00000AA)
+#define NT_STATUS_INSUFFICIENT_LOGON_INFO ((nt_status) 0xC0000250)
+#define NT_STATUS_INSUFFICIENT_NVRAM_RESOURCES ((nt_status) 0xC0000454)
+#define NT_STATUS_INSUFFICIENT_POWER ((nt_status) 0xC00002DE)
+#define NT_STATUS_INSUFFICIENT_RESOURCES ((nt_status) 0xC000009A)
+#define NT_STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE ((nt_status) 0xC0000416)
+#define NT_STATUS_INSUFF_SERVER_RESOURCES ((nt_status) 0xC0000205)
+#define NT_STATUS_INTEGER_DIVIDE_BY_ZERO ((nt_status) 0xC0000094)
+#define NT_STATUS_INTEGER_OVERFLOW ((nt_status) 0xC0000095)
+#define NT_STATUS_INTERNAL_DB_CORRUPTION ((nt_status) 0xC00000E4)
+#define NT_STATUS_INTERNAL_DB_ERROR ((nt_status) 0xC0000158)
+#define NT_STATUS_INTERNAL_ERROR ((nt_status) 0xC00000E5)
+#define NT_STATUS_INTERRUPT_STILL_CONNECTED ((nt_status) 0x00000128)
+#define NT_STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED ((nt_status) 0x00000127)
+#define NT_STATUS_INVALID_ACCOUNT_NAME ((nt_status) 0xC0000062)
+#define NT_STATUS_INVALID_ACE_CONDITION ((nt_status) 0xC00001A2)
+#define NT_STATUS_INVALID_ACL ((nt_status) 0xC0000077)
+#define NT_STATUS_INVALID_ADDRESS ((nt_status) 0xC0000141)
+#define NT_STATUS_INVALID_ADDRESS_COMPONENT ((nt_status) 0xC0000207)
+#define NT_STATUS_INVALID_ADDRESS_WILDCARD ((nt_status) 0xC0000208)
+#define NT_STATUS_INVALID_BLOCK_LENGTH ((nt_status) 0xC0000173)
+#define NT_STATUS_INVALID_BUFFER_SIZE ((nt_status) 0xC0000206)
+#define NT_STATUS_INVALID_CID ((nt_status) 0xC000000B)
+#define NT_STATUS_INVALID_COMPUTER_NAME ((nt_status) 0xC0000122)
+#define NT_STATUS_INVALID_CONNECTION ((nt_status) 0xC0000140)
+#define NT_STATUS_INVALID_CRUNTIME_PARAMETER ((nt_status) 0xC0000417)
+#define NT_STATUS_INVALID_DEVICE_OBJECT_PARAMETER ((nt_status) 0xC0000369)
+#define NT_STATUS_INVALID_DEVICE_REQUEST ((nt_status) 0xC0000010)
+#define NT_STATUS_INVALID_DEVICE_STATE ((nt_status) 0xC0000184)
+#define NT_STATUS_INVALID_DISPOSITION ((nt_status) 0xC0000026)
+#define NT_STATUS_INVALID_DOMAIN_ROLE ((nt_status) 0xC00000DE)
+#define NT_STATUS_INVALID_DOMAIN_STATE ((nt_status) 0xC00000DD)
+#define NT_STATUS_INVALID_EA_FLAG ((nt_status) 0x80000015)
+#define NT_STATUS_INVALID_EA_NAME ((nt_status) 0x80000013)
+#define NT_STATUS_INVALID_FILE_FOR_SECTION ((nt_status) 0xC0000020)
+#define NT_STATUS_INVALID_GROUP_ATTRIBUTES ((nt_status) 0xC00000A4)
+#define NT_STATUS_INVALID_HANDLE ((nt_status) 0xC0000008)
+#define NT_STATUS_INVALID_HW_PROFILE ((nt_status) 0xC0000260)
+#define NT_STATUS_INVALID_IDN_NORMALIZATION ((nt_status) 0xC0000716)
+#define NT_STATUS_INVALID_ID_AUTHORITY ((nt_status) 0xC0000084)
+#define NT_STATUS_INVALID_IMAGE_FORMAT ((nt_status) 0xC000007B)
+#define NT_STATUS_INVALID_IMAGE_HASH ((nt_status) 0xC0000428)
+#define NT_STATUS_INVALID_IMAGE_LE_FORMAT ((nt_status) 0xC000012E)
+#define NT_STATUS_INVALID_IMAGE_NE_FORMAT ((nt_status) 0xC000011B)
+#define NT_STATUS_INVALID_IMAGE_NOT_MZ ((nt_status) 0xC000012F)
+#define NT_STATUS_INVALID_IMAGE_PROTECT ((nt_status) 0xC0000130)
+#define NT_STATUS_INVALID_IMAGE_WIN_16 ((nt_status) 0xC0000131)
+#define NT_STATUS_INVALID_IMAGE_WIN_32 ((nt_status) 0xC0000359)
+#define NT_STATUS_INVALID_IMAGE_WIN_64 ((nt_status) 0xC000035A)
+#define NT_STATUS_INVALID_IMPORT_OF_NON_DLL ((nt_status) 0xC000036F)
+#define NT_STATUS_INVALID_INFO_CLASS ((nt_status) 0xC0000003)
+#define NT_STATUS_INVALID_LABEL ((nt_status) 0xC0000446)
+#define NT_STATUS_INVALID_LDT_DESCRIPTOR ((nt_status) 0xC000011A)
+#define NT_STATUS_INVALID_LDT_OFFSET ((nt_status) 0xC0000119)
+#define NT_STATUS_INVALID_LDT_SIZE ((nt_status) 0xC0000118)
+#define NT_STATUS_INVALID_LEVEL ((nt_status) 0xC0000148)
+#define NT_STATUS_INVALID_LOCK_RANGE ((nt_status) 0xC00001A1)
+#define NT_STATUS_INVALID_LOCK_SEQUENCE ((nt_status) 0xC000001E)
+#define NT_STATUS_INVALID_LOGON_HOURS ((nt_status) 0xC000006F)
+#define NT_STATUS_INVALID_LOGON_TYPE ((nt_status) 0xC000010B)
+#define NT_STATUS_INVALID_MEMBER ((nt_status) 0xC000017B)
+#define NT_STATUS_INVALID_MESSAGE ((nt_status) 0xC0000702)
+#define NT_STATUS_INVALID_NETWORK_RESPONSE ((nt_status) 0xC00000C3)
+#define NT_STATUS_INVALID_OPLOCK_PROTOCOL ((nt_status) 0xC00000E3)
+#define NT_STATUS_INVALID_OWNER ((nt_status) 0xC000005A)
+#define NT_STATUS_INVALID_PAGE_PROTECTION ((nt_status) 0xC0000045)
+#define NT_STATUS_INVALID_PARAMETER ((nt_status) 0xC000000D)
+#define NT_STATUS_INVALID_PARAMETER_1 ((nt_status) 0xC00000EF)
+#define NT_STATUS_INVALID_PARAMETER_10 ((nt_status) 0xC00000F8)
+#define NT_STATUS_INVALID_PARAMETER_11 ((nt_status) 0xC00000F9)
+#define NT_STATUS_INVALID_PARAMETER_12 ((nt_status) 0xC00000FA)
+#define NT_STATUS_INVALID_PARAMETER_2 ((nt_status) 0xC00000F0)
+#define NT_STATUS_INVALID_PARAMETER_3 ((nt_status) 0xC00000F1)
+#define NT_STATUS_INVALID_PARAMETER_4 ((nt_status) 0xC00000F2)
+#define NT_STATUS_INVALID_PARAMETER_5 ((nt_status) 0xC00000F3)
+#define NT_STATUS_INVALID_PARAMETER_6 ((nt_status) 0xC00000F4)
+#define NT_STATUS_INVALID_PARAMETER_7 ((nt_status) 0xC00000F5)
+#define NT_STATUS_INVALID_PARAMETER_8 ((nt_status) 0xC00000F6)
+#define NT_STATUS_INVALID_PARAMETER_9 ((nt_status) 0xC00000F7)
+#define NT_STATUS_INVALID_PARAMETER_MIX ((nt_status) 0xC0000030)
+#define NT_STATUS_INVALID_PIPE_STATE ((nt_status) 0xC00000AD)
+#define NT_STATUS_INVALID_PLUGPLAY_DEVICE_PATH ((nt_status) 0xC0000261)
+#define NT_STATUS_INVALID_PORT_ATTRIBUTES ((nt_status) 0xC000002E)
+#define NT_STATUS_INVALID_PORT_HANDLE ((nt_status) 0xC0000042)
+#define NT_STATUS_INVALID_PRIMARY_GROUP ((nt_status) 0xC000005B)
+#define NT_STATUS_INVALID_QUOTA_LOWER ((nt_status) 0xC0000031)
+#define NT_STATUS_INVALID_READ_MODE ((nt_status) 0xC00000B4)
+#define NT_STATUS_INVALID_SECURITY_DESCR ((nt_status) 0xC0000079)
+#define NT_STATUS_INVALID_SERVER_STATE ((nt_status) 0xC00000DC)
+#define NT_STATUS_INVALID_SID ((nt_status) 0xC0000078)
+#define NT_STATUS_INVALID_SIGNATURE ((nt_status) 0xC000A000)
+#define NT_STATUS_INVALID_SUB_AUTHORITY ((nt_status) 0xC0000076)
+#define NT_STATUS_INVALID_SYSTEM_SERVICE ((nt_status) 0xC000001C)
+#define NT_STATUS_INVALID_TASK_INDEX ((nt_status) 0xC0000501)
+#define NT_STATUS_INVALID_TASK_NAME ((nt_status) 0xC0000500)
+#define NT_STATUS_INVALID_THREAD ((nt_status) 0xC000071C)
+#define NT_STATUS_INVALID_TRANSACTION ((nt_status) 0xC0190002)
+#define NT_STATUS_INVALID_UNWIND_TARGET ((nt_status) 0xC0000029)
+#define NT_STATUS_INVALID_USER_BUFFER ((nt_status) 0xC00000E8)
+#define NT_STATUS_INVALID_USER_PRINCIPAL_NAME ((nt_status) 0xC000041C)
+#define NT_STATUS_INVALID_VARIANT ((nt_status) 0xC0000232)
+#define NT_STATUS_INVALID_VIEW_SIZE ((nt_status) 0xC000001F)
+#define NT_STATUS_INVALID_VOLUME_LABEL ((nt_status) 0xC0000086)
+#define NT_STATUS_INVALID_WORKSTATION ((nt_status) 0xC0000070)
+#define NT_STATUS_IN_PAGE_ERROR ((nt_status) 0xC0000006)
+#define NT_STATUS_IO_DEVICE_ERROR ((nt_status) 0xC0000185)
+#define NT_STATUS_IO_PRIVILEGE_FAILED ((nt_status) 0xC0000137)
+#define NT_STATUS_IO_REISSUE_AS_CACHED ((nt_status) 0xC0040039)
+#define NT_STATUS_IO_REPARSE_DATA_INVALID ((nt_status) 0xC0000278)
+#define NT_STATUS_IO_REPARSE_TAG_INVALID ((nt_status) 0xC0000276)
+#define NT_STATUS_IO_REPARSE_TAG_MISMATCH ((nt_status) 0xC0000277)
+#define NT_STATUS_IO_REPARSE_TAG_NOT_HANDLED ((nt_status) 0xC0000279)
+#define NT_STATUS_IO_TIMEOUT ((nt_status) 0xC00000B5)
+#define NT_STATUS_IPSEC_AUTH_FIREWALL_DROP ((nt_status) 0xC0360008)
+#define NT_STATUS_IPSEC_BAD_SPI ((nt_status) 0xC0360001)
+#define NT_STATUS_IPSEC_CLEAR_TEXT_DROP ((nt_status) 0xC0360007)
+#define NT_STATUS_IPSEC_DOSP_BLOCK ((nt_status) 0xC0368000)
+#define NT_STATUS_IPSEC_DOSP_INVALID_PACKET ((nt_status) 0xC0368002)
+#define NT_STATUS_IPSEC_DOSP_KEYMOD_NOT_ALLOWED ((nt_status) 0xC0368005)
+#define NT_STATUS_IPSEC_DOSP_MAX_ENTRIES ((nt_status) 0xC0368004)
+#define NT_STATUS_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES ((nt_status) 0xC0368006)
+#define NT_STATUS_IPSEC_DOSP_RECEIVED_MULTICAST ((nt_status) 0xC0368001)
+#define NT_STATUS_IPSEC_DOSP_STATE_LOOKUP_FAILED ((nt_status) 0xC0368003)
+#define NT_STATUS_IPSEC_INTEGRITY_CHECK_FAILED ((nt_status) 0xC0360006)
+#define NT_STATUS_IPSEC_INVALID_PACKET ((nt_status) 0xC0360005)
+#define NT_STATUS_IPSEC_QUEUE_OVERFLOW ((nt_status) 0xC000A010)
+#define NT_STATUS_IPSEC_REPLAY_CHECK_FAILED ((nt_status) 0xC0360004)
+#define NT_STATUS_IPSEC_SA_LIFETIME_EXPIRED ((nt_status) 0xC0360002)
+#define NT_STATUS_IPSEC_THROTTLE_DROP ((nt_status) 0xC0360009)
+#define NT_STATUS_IPSEC_WRONG_SA ((nt_status) 0xC0360003)
+#define NT_STATUS_IP_ADDRESS_CONFLICT1 ((nt_status) 0xC0000254)
+#define NT_STATUS_IP_ADDRESS_CONFLICT2 ((nt_status) 0xC0000255)
+#define NT_STATUS_ISSUING_CA_UNTRUSTED ((nt_status) 0xC000038A)
+#define NT_STATUS_ISSUING_CA_UNTRUSTED_KDC ((nt_status) 0xC000040D)
+#define NT_STATUS_JOURNAL_DELETE_IN_PROGRESS ((nt_status) 0xC00002B7)
+#define NT_STATUS_JOURNAL_ENTRY_DELETED ((nt_status) 0xC00002CF)
+#define NT_STATUS_JOURNAL_NOT_ACTIVE ((nt_status) 0xC00002B8)
+#define NT_STATUS_KDC_CERT_EXPIRED ((nt_status) 0xC000040E)
+#define NT_STATUS_KDC_CERT_REVOKED ((nt_status) 0xC000040F)
+#define NT_STATUS_KDC_INVALID_REQUEST ((nt_status) 0xC00002FB)
+#define NT_STATUS_KDC_UNABLE_TO_REFER ((nt_status) 0xC00002FC)
+#define NT_STATUS_KDC_UNKNOWN_ETYPE ((nt_status) 0xC00002FD)
+#define NT_STATUS_KEY_DELETED ((nt_status) 0xC000017C)
+#define NT_STATUS_KEY_HAS_CHILDREN ((nt_status) 0xC0000180)
+#define NT_STATUS_LAST_ADMIN ((nt_status) 0xC0000069)
+#define NT_STATUS_LICENSE_QUOTA_EXCEEDED ((nt_status) 0xC0000259)
+#define NT_STATUS_LICENSE_VIOLATION ((nt_status) 0xC000026A)
+#define NT_STATUS_LINK_FAILED ((nt_status) 0xC000013E)
+#define NT_STATUS_LINK_TIMEOUT ((nt_status) 0xC000013F)
+#define NT_STATUS_LM_CROSS_ENCRYPTION_REQUIRED ((nt_status) 0xC000017F)
+#define NT_STATUS_LOCAL_DISCONNECT ((nt_status) 0xC000013B)
+#define NT_STATUS_LOCAL_USER_SESSION_KEY ((nt_status) 0x40000006)
+#define NT_STATUS_LOCK_NOT_GRANTED ((nt_status) 0xC0000055)
+#define NT_STATUS_LOGIN_TIME_RESTRICTION ((nt_status) 0xC0000247)
+#define NT_STATUS_LOGIN_WKSTA_RESTRICTION ((nt_status) 0xC0000248)
+#define NT_STATUS_LOGON_FAILURE ((nt_status) 0xC000006D)
+#define NT_STATUS_LOGON_NOT_GRANTED ((nt_status) 0xC0000155)
+#define NT_STATUS_LOGON_SERVER_CONFLICT ((nt_status) 0xC0000132)
+#define NT_STATUS_LOGON_SESSION_COLLISION ((nt_status) 0xC0000105)
+#define NT_STATUS_LOGON_SESSION_EXISTS ((nt_status) 0xC00000EE)
+#define NT_STATUS_LOGON_TYPE_NOT_GRANTED ((nt_status) 0xC000015B)
+#define NT_STATUS_LOG_APPENDED_FLUSH_FAILED ((nt_status) 0xC01A002F)
+#define NT_STATUS_LOG_ARCHIVE_IN_PROGRESS ((nt_status) 0xC01A0021)
+#define NT_STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS ((nt_status) 0xC01A0020)
+#define NT_STATUS_LOG_BLOCKS_EXHAUSTED ((nt_status) 0xC01A0006)
+#define NT_STATUS_LOG_BLOCK_INCOMPLETE ((nt_status) 0xC01A0004)
+#define NT_STATUS_LOG_BLOCK_INVALID ((nt_status) 0xC01A000A)
+#define NT_STATUS_LOG_BLOCK_VERSION ((nt_status) 0xC01A0009)
+#define NT_STATUS_LOG_CANT_DELETE ((nt_status) 0xC01A0011)
+#define NT_STATUS_LOG_CLIENT_ALREADY_REGISTERED ((nt_status) 0xC01A0024)
+#define NT_STATUS_LOG_CLIENT_NOT_REGISTERED ((nt_status) 0xC01A0025)
+#define NT_STATUS_LOG_CONTAINER_LIMIT_EXCEEDED ((nt_status) 0xC01A0012)
+#define NT_STATUS_LOG_CONTAINER_OPEN_FAILED ((nt_status) 0xC01A0029)
+#define NT_STATUS_LOG_CONTAINER_READ_FAILED ((nt_status) 0xC01A0027)
+#define NT_STATUS_LOG_CONTAINER_STATE_INVALID ((nt_status) 0xC01A002A)
+#define NT_STATUS_LOG_CONTAINER_WRITE_FAILED ((nt_status) 0xC01A0028)
+#define NT_STATUS_LOG_CORRUPTION_DETECTED ((nt_status) 0xC0190030)
+#define NT_STATUS_LOG_DEDICATED ((nt_status) 0xC01A001F)
+#define NT_STATUS_LOG_EPHEMERAL ((nt_status) 0xC01A0022)
+#define NT_STATUS_LOG_FILE_FULL ((nt_status) 0xC0000188)
+#define NT_STATUS_LOG_FULL ((nt_status) 0xC01A001D)
+#define NT_STATUS_LOG_FULL_HANDLER_IN_PROGRESS ((nt_status) 0xC01A0026)
+#define NT_STATUS_LOG_GROWTH_FAILED ((nt_status) 0xC0190019)
+#define NT_STATUS_LOG_HARD_ERROR ((nt_status) 0x4000001A)
+#define NT_STATUS_LOG_INCONSISTENT_SECURITY ((nt_status) 0xC01A002E)
+#define NT_STATUS_LOG_INVALID_RANGE ((nt_status) 0xC01A0005)
+#define NT_STATUS_LOG_METADATA_CORRUPT ((nt_status) 0xC01A000D)
+#define NT_STATUS_LOG_METADATA_FLUSH_FAILED ((nt_status) 0xC01A002D)
+#define NT_STATUS_LOG_METADATA_INCONSISTENT ((nt_status) 0xC01A000F)
+#define NT_STATUS_LOG_METADATA_INVALID ((nt_status) 0xC01A000E)
+#define NT_STATUS_LOG_MULTIPLEXED ((nt_status) 0xC01A001E)
+#define NT_STATUS_LOG_NOT_ENOUGH_CONTAINERS ((nt_status) 0xC01A0023)
+#define NT_STATUS_LOG_NO_RESTART ((nt_status) 0x401A000C)
+#define NT_STATUS_LOG_PINNED ((nt_status) 0xC01A002C)
+#define NT_STATUS_LOG_PINNED_ARCHIVE_TAIL ((nt_status) 0xC01A0018)
+#define NT_STATUS_LOG_PINNED_RESERVATION ((nt_status) 0xC01A0030)
+#define NT_STATUS_LOG_POLICY_ALREADY_INSTALLED ((nt_status) 0xC01A0014)
+#define NT_STATUS_LOG_POLICY_CONFLICT ((nt_status) 0xC01A0017)
+#define NT_STATUS_LOG_POLICY_INVALID ((nt_status) 0xC01A0016)
+#define NT_STATUS_LOG_POLICY_NOT_INSTALLED ((nt_status) 0xC01A0015)
+#define NT_STATUS_LOG_READ_CONTEXT_INVALID ((nt_status) 0xC01A0007)
+#define NT_STATUS_LOG_READ_MODE_INVALID ((nt_status) 0xC01A000B)
+#define NT_STATUS_LOG_RECORDS_RESERVED_INVALID ((nt_status) 0xC01A001A)
+#define NT_STATUS_LOG_RECORD_NONEXISTENT ((nt_status) 0xC01A0019)
+#define NT_STATUS_LOG_RESERVATION_INVALID ((nt_status) 0xC01A0010)
+#define NT_STATUS_LOG_RESIZE_INVALID_SIZE ((nt_status) 0xC019000B)
+#define NT_STATUS_LOG_RESTART_INVALID ((nt_status) 0xC01A0008)
+#define NT_STATUS_LOG_SECTOR_INVALID ((nt_status) 0xC01A0001)
+#define NT_STATUS_LOG_SECTOR_PARITY_INVALID ((nt_status) 0xC01A0002)
+#define NT_STATUS_LOG_SECTOR_REMAPPED ((nt_status) 0xC01A0003)
+#define NT_STATUS_LOG_SPACE_RESERVED_INVALID ((nt_status) 0xC01A001B)
+#define NT_STATUS_LOG_START_OF_LOG ((nt_status) 0xC01A0013)
+#define NT_STATUS_LOG_STATE_INVALID ((nt_status) 0xC01A002B)
+#define NT_STATUS_LOG_TAIL_INVALID ((nt_status) 0xC01A001C)
+#define NT_STATUS_LONGJUMP ((nt_status) 0x80000026)
+#define NT_STATUS_LOST_WRITEBEHIND_DATA ((nt_status) 0xC0000222)
+#define NT_STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR ((nt_status) 0xC000A082)
+#define NT_STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED ((nt_status) 0xC000A080)
+#define NT_STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR ((nt_status) 0xC000A081)
+#define NT_STATUS_LPC_INVALID_CONNECTION_USAGE ((nt_status) 0xC0000706)
+#define NT_STATUS_LPC_RECEIVE_BUFFER_EXPECTED ((nt_status) 0xC0000705)
+#define NT_STATUS_LPC_REPLY_LOST ((nt_status) 0xC0000253)
+#define NT_STATUS_LPC_REQUESTS_NOT_ALLOWED ((nt_status) 0xC0000707)
+#define NT_STATUS_LUIDS_EXHAUSTED ((nt_status) 0xC0000075)
+#define NT_STATUS_MAGAZINE_NOT_PRESENT ((nt_status) 0xC0000286)
+#define NT_STATUS_MAPPED_ALIGNMENT ((nt_status) 0xC0000220)
+#define NT_STATUS_MAPPED_FILE_SIZE_ZERO ((nt_status) 0xC000011E)
+#define NT_STATUS_MARSHALL_OVERFLOW ((nt_status) 0xC0000231)
+#define NT_STATUS_MAX_REFERRALS_EXCEEDED ((nt_status) 0xC00002F4)
+#define NT_STATUS_MCA_EXCEPTION ((nt_status) 0xC0000713)
+#define NT_STATUS_MCA_OCCURED ((nt_status) 0xC000036A)
+#define NT_STATUS_MEDIA_CHANGED ((nt_status) 0x8000001C)
+#define NT_STATUS_MEDIA_CHECK ((nt_status) 0x80000020)
+#define NT_STATUS_MEDIA_WRITE_PROTECTED ((nt_status) 0xC00000A2)
+#define NT_STATUS_MEMBERS_PRIMARY_GROUP ((nt_status) 0xC0000127)
+#define NT_STATUS_MEMBER_IN_ALIAS ((nt_status) 0xC0000153)
+#define NT_STATUS_MEMBER_IN_GROUP ((nt_status) 0xC0000067)
+#define NT_STATUS_MEMBER_NOT_IN_ALIAS ((nt_status) 0xC0000152)
+#define NT_STATUS_MEMBER_NOT_IN_GROUP ((nt_status) 0xC0000068)
+#define NT_STATUS_MEMORY_NOT_ALLOCATED ((nt_status) 0xC00000A0)
+#define NT_STATUS_MESSAGE_LOST ((nt_status) 0xC0000701)
+#define NT_STATUS_MESSAGE_NOT_FOUND ((nt_status) 0xC0000109)
+#define NT_STATUS_MESSAGE_RETRIEVED ((nt_status) 0x4000002E)
+#define NT_STATUS_MFT_TOO_FRAGMENTED ((nt_status) 0xC0000304)
+#define NT_STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION ((nt_status) 0xC0190024)
+#define NT_STATUS_MISSING_SYSTEMFILE ((nt_status) 0xC0000143)
+#define NT_STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM ((nt_status) 0xC01D0003)
+#define NT_STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK ((nt_status) 0xC01D0009)
+#define NT_STATUS_MONITOR_INVALID_MANUFACTURE_DATE ((nt_status) 0xC01D000A)
+#define NT_STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK ((nt_status) 0xC01D0006)
+#define NT_STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK ((nt_status) 0xC01D0004)
+#define NT_STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK ((nt_status) 0xC01D0007)
+#define NT_STATUS_MONITOR_NO_DESCRIPTOR ((nt_status) 0xC01D0001)
+#define NT_STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA ((nt_status) 0xC01D0008)
+#define NT_STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT ((nt_status) 0xC01D0002)
+#define NT_STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED ((nt_status) 0xC01D0005)
+#define NT_STATUS_MORE_ENTRIES ((nt_status) 0x00000105)
+#define NT_STATUS_MORE_PROCESSING_REQUIRED ((nt_status) 0xC0000016)
+#define NT_STATUS_MOUNT_POINT_NOT_RESOLVED ((nt_status) 0xC0000368)
+#define NT_STATUS_MP_PROCESSOR_MISMATCH ((nt_status) 0x40000029)
+#define NT_STATUS_MUI_FILE_NOT_FOUND ((nt_status) 0xC00B0001)
+#define NT_STATUS_MUI_FILE_NOT_LOADED ((nt_status) 0xC00B0006)
+#define NT_STATUS_MUI_INVALID_FILE ((nt_status) 0xC00B0002)
+#define NT_STATUS_MUI_INVALID_LOCALE_NAME ((nt_status) 0xC00B0004)
+#define NT_STATUS_MUI_INVALID_RC_CONFIG ((nt_status) 0xC00B0003)
+#define NT_STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME ((nt_status) 0xC00B0005)
+#define NT_STATUS_MUST_BE_KDC ((nt_status) 0xC00002F5)
+#define NT_STATUS_MUTANT_LIMIT_EXCEEDED ((nt_status) 0xC0000191)
+#define NT_STATUS_MUTANT_NOT_OWNED ((nt_status) 0xC0000046)
+#define NT_STATUS_MUTUAL_AUTHENTICATION_FAILED ((nt_status) 0xC00002C3)
+#define NT_STATUS_NAME_TOO_LONG ((nt_status) 0xC0000106)
+#define NT_STATUS_NDIS_ADAPTER_NOT_FOUND ((nt_status) 0xC0230006)
+#define NT_STATUS_NDIS_ADAPTER_NOT_READY ((nt_status) 0xC0230011)
+#define NT_STATUS_NDIS_ADAPTER_REMOVED ((nt_status) 0xC0230018)
+#define NT_STATUS_NDIS_ALREADY_MAPPED ((nt_status) 0xC023001D)
+#define NT_STATUS_NDIS_BAD_CHARACTERISTICS ((nt_status) 0xC0230005)
+#define NT_STATUS_NDIS_BAD_VERSION ((nt_status) 0xC0230004)
+#define NT_STATUS_NDIS_BUFFER_TOO_SHORT ((nt_status) 0xC0230016)
+#define NT_STATUS_NDIS_CLOSING ((nt_status) 0xC0230002)
+#define NT_STATUS_NDIS_DEVICE_FAILED ((nt_status) 0xC0230008)
+#define NT_STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED ((nt_status) 0xC0232000)
+#define NT_STATUS_NDIS_DOT11_MEDIA_IN_USE ((nt_status) 0xC0232001)
+#define NT_STATUS_NDIS_DOT11_POWER_STATE_INVALID ((nt_status) 0xC0232002)
+#define NT_STATUS_NDIS_ERROR_READING_FILE ((nt_status) 0xC023001C)
+#define NT_STATUS_NDIS_FILE_NOT_FOUND ((nt_status) 0xC023001B)
+#define NT_STATUS_NDIS_GROUP_ADDRESS_IN_USE ((nt_status) 0xC023001A)
+#define NT_STATUS_NDIS_INDICATION_REQUIRED ((nt_status) 0x40230001)
+#define NT_STATUS_NDIS_INTERFACE_NOT_FOUND ((nt_status) 0xC023002B)
+#define NT_STATUS_NDIS_INVALID_ADDRESS ((nt_status) 0xC0230022)
+#define NT_STATUS_NDIS_INVALID_DATA ((nt_status) 0xC0230015)
+#define NT_STATUS_NDIS_INVALID_DEVICE_REQUEST ((nt_status) 0xC0230010)
+#define NT_STATUS_NDIS_INVALID_LENGTH ((nt_status) 0xC0230014)
+#define NT_STATUS_NDIS_INVALID_OID ((nt_status) 0xC0230017)
+#define NT_STATUS_NDIS_INVALID_PACKET ((nt_status) 0xC023000F)
+#define NT_STATUS_NDIS_INVALID_PORT ((nt_status) 0xC023002D)
+#define NT_STATUS_NDIS_INVALID_PORT_STATE ((nt_status) 0xC023002E)
+#define NT_STATUS_NDIS_LOW_POWER_STATE ((nt_status) 0xC023002F)
+#define NT_STATUS_NDIS_MEDIA_DISCONNECTED ((nt_status) 0xC023001F)
+#define NT_STATUS_NDIS_MULTICAST_EXISTS ((nt_status) 0xC023000A)
+#define NT_STATUS_NDIS_MULTICAST_FULL ((nt_status) 0xC0230009)
+#define NT_STATUS_NDIS_MULTICAST_NOT_FOUND ((nt_status) 0xC023000B)
+#define NT_STATUS_NDIS_NOT_SUPPORTED ((nt_status) 0xC02300BB)
+#define NT_STATUS_NDIS_OFFLOAD_CONNECTION_REJECTED ((nt_status) 0xC0231012)
+#define NT_STATUS_NDIS_OFFLOAD_PATH_REJECTED ((nt_status) 0xC0231013)
+#define NT_STATUS_NDIS_OFFLOAD_POLICY ((nt_status) 0xC023100F)
+#define NT_STATUS_NDIS_OPEN_FAILED ((nt_status) 0xC0230007)
+#define NT_STATUS_NDIS_PAUSED ((nt_status) 0xC023002A)
+#define NT_STATUS_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULL ((nt_status) 0xC0232004)
+#define NT_STATUS_NDIS_PM_WOL_PATTERN_LIST_FULL ((nt_status) 0xC0232003)
+#define NT_STATUS_NDIS_REQUEST_ABORTED ((nt_status) 0xC023000C)
+#define NT_STATUS_NDIS_RESET_IN_PROGRESS ((nt_status) 0xC023000D)
+#define NT_STATUS_NDIS_RESOURCE_CONFLICT ((nt_status) 0xC023001E)
+#define NT_STATUS_NDIS_UNSUPPORTED_MEDIA ((nt_status) 0xC0230019)
+#define NT_STATUS_NDIS_UNSUPPORTED_REVISION ((nt_status) 0xC023002C)
+#define NT_STATUS_ND_QUEUE_OVERFLOW ((nt_status) 0xC000A011)
+#define NT_STATUS_NETLOGON_NOT_STARTED ((nt_status) 0xC0000192)
+#define NT_STATUS_NETWORK_ACCESS_DENIED ((nt_status) 0xC00000CA)
+#define NT_STATUS_NETWORK_BUSY ((nt_status) 0xC00000BF)
+#define NT_STATUS_NETWORK_CREDENTIAL_CONFLICT ((nt_status) 0xC0000195)
+#define NT_STATUS_NETWORK_NAME_DELETED ((nt_status) 0xC00000C9)
+#define NT_STATUS_NETWORK_OPEN_RESTRICTION ((nt_status) 0xC0000201)
+#define NT_STATUS_NETWORK_SESSION_EXPIRED ((nt_status) 0xC000035C)
+#define NT_STATUS_NETWORK_UNREACHABLE ((nt_status) 0xC000023C)
+#define NT_STATUS_NET_WRITE_FAULT ((nt_status) 0xC00000D2)
+#define NT_STATUS_NOINTERFACE ((nt_status) 0xC00002B9)
+#define NT_STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT ((nt_status) 0xC0000198)
+#define NT_STATUS_NOLOGON_SERVER_TRUST_ACCOUNT ((nt_status) 0xC000019A)
+#define NT_STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT ((nt_status) 0xC0000199)
+#define NT_STATUS_NONCONTINUABLE_EXCEPTION ((nt_status) 0xC0000025)
+#define NT_STATUS_NONEXISTENT_EA_ENTRY ((nt_status) 0xC0000051)
+#define NT_STATUS_NONEXISTENT_SECTOR ((nt_status) 0xC0000015)
+#define NT_STATUS_NONE_MAPPED ((nt_status) 0xC0000073)
+#define NT_STATUS_NOTHING_TO_TERMINATE ((nt_status) 0x00000122)
+#define NT_STATUS_NOTIFICATION_GUID_ALREADY_DEFINED ((nt_status) 0xC00001A4)
+#define NT_STATUS_NOTIFY_CLEANUP ((nt_status) 0x0000010B)
+#define NT_STATUS_NOTIFY_ENUM_DIR ((nt_status) 0x0000010C)
+#define NT_STATUS_NOT_ALL_ASSIGNED ((nt_status) 0x00000106)
+#define NT_STATUS_NOT_A_DIRECTORY ((nt_status) 0xC0000103)
+#define NT_STATUS_NOT_A_REPARSE_POINT ((nt_status) 0xC0000275)
+#define NT_STATUS_NOT_CAPABLE ((nt_status) 0xC0000429)
+#define NT_STATUS_NOT_CLIENT_SESSION ((nt_status) 0xC0000217)
+#define NT_STATUS_NOT_COMMITTED ((nt_status) 0xC000002D)
+#define NT_STATUS_NOT_EXPORT_FORMAT ((nt_status) 0xC0000292)
+#define NT_STATUS_NOT_FOUND ((nt_status) 0xC0000225)
+#define NT_STATUS_NOT_IMPLEMENTED ((nt_status) 0xC0000002)
+#define NT_STATUS_NOT_LOCKED ((nt_status) 0xC000002A)
+#define NT_STATUS_NOT_LOGON_PROCESS ((nt_status) 0xC00000ED)
+#define NT_STATUS_NOT_MAPPED_DATA ((nt_status) 0xC0000088)
+#define NT_STATUS_NOT_MAPPED_VIEW ((nt_status) 0xC0000019)
+#define NT_STATUS_NOT_REGISTRY_FILE ((nt_status) 0xC000015C)
+#define NT_STATUS_NOT_SAFE_MODE_DRIVER ((nt_status) 0xC000035F)
+#define NT_STATUS_NOT_SAME_DEVICE ((nt_status) 0xC00000D4)
+#define NT_STATUS_NOT_SERVER_SESSION ((nt_status) 0xC0000216)
+#define NT_STATUS_NOT_SNAPSHOT_VOLUME ((nt_status) 0xC0190047)
+#define NT_STATUS_NOT_SUPPORTED ((nt_status) 0xC00000BB)
+#define NT_STATUS_NOT_SUPPORTED_ON_SBS ((nt_status) 0xC0000300)
+#define NT_STATUS_NOT_TINY_STREAM ((nt_status) 0xC0000226)
+#define NT_STATUS_NO_BROWSER_SERVERS_FOUND ((nt_status) 0xC000021C)
+#define NT_STATUS_NO_CALLBACK_ACTIVE ((nt_status) 0xC0000258)
+#define NT_STATUS_NO_DATA_DETECTED ((nt_status) 0x80000022)
+#define NT_STATUS_NO_EAS_ON_FILE ((nt_status) 0xC0000052)
+#define NT_STATUS_NO_EFS ((nt_status) 0xC000028E)
+#define NT_STATUS_NO_EVENT_PAIR ((nt_status) 0xC000014E)
+#define NT_STATUS_NO_GUID_TRANSLATION ((nt_status) 0xC000010C)
+#define NT_STATUS_NO_IMPERSONATION_TOKEN ((nt_status) 0xC000005C)
+#define NT_STATUS_NO_INHERITANCE ((nt_status) 0x8000000B)
+#define NT_STATUS_NO_IP_ADDRESSES ((nt_status) 0xC00002F1)
+#define NT_STATUS_NO_KERB_KEY ((nt_status) 0xC0000322)
+#define NT_STATUS_NO_LDT ((nt_status) 0xC0000117)
+#define NT_STATUS_NO_LINK_TRACKING_IN_TRANSACTION ((nt_status) 0xC0190059)
+#define NT_STATUS_NO_LOGON_SERVERS ((nt_status) 0xC000005E)
+#define NT_STATUS_NO_LOG_SPACE ((nt_status) 0xC000017D)
+#define NT_STATUS_NO_MATCH ((nt_status) 0xC0000272)
+#define NT_STATUS_NO_MEDIA ((nt_status) 0xC0000178)
+#define NT_STATUS_NO_MEDIA_IN_DEVICE ((nt_status) 0xC0000013)
+#define NT_STATUS_NO_MEMORY ((nt_status) 0xC0000017)
+#define NT_STATUS_NO_MORE_EAS ((nt_status) 0x80000012)
+#define NT_STATUS_NO_MORE_ENTRIES ((nt_status) 0x8000001A)
+#define NT_STATUS_NO_MORE_FILES ((nt_status) 0x80000006)
+#define NT_STATUS_NO_MORE_MATCHES ((nt_status) 0xC0000273)
+#define NT_STATUS_NO_PAGEFILE ((nt_status) 0xC0000147)
+#define NT_STATUS_NO_PA_DATA ((nt_status) 0xC00002F8)
+#define NT_STATUS_NO_QUOTAS_FOR_ACCOUNT ((nt_status) 0x0000010D)
+#define NT_STATUS_NO_RECOVERY_POLICY ((nt_status) 0xC000028D)
+#define NT_STATUS_NO_S4U_PROT_SUPPORT ((nt_status) 0xC000040A)
+#define NT_STATUS_NO_SAVEPOINT_WITH_OPEN_FILES ((nt_status) 0xC0190048)
+#define NT_STATUS_NO_SECRETS ((nt_status) 0xC0000371)
+#define NT_STATUS_NO_SECURITY_CONTEXT ((nt_status) 0xC000042D)
+#define NT_STATUS_NO_SECURITY_ON_OBJECT ((nt_status) 0xC00000D7)
+#define NT_STATUS_NO_SPOOL_SPACE ((nt_status) 0xC00000C7)
+#define NT_STATUS_NO_SUCH_ALIAS ((nt_status) 0xC0000151)
+#define NT_STATUS_NO_SUCH_DEVICE ((nt_status) 0xC000000E)
+#define NT_STATUS_NO_SUCH_DOMAIN ((nt_status) 0xC00000DF)
+#define NT_STATUS_NO_SUCH_FILE ((nt_status) 0xC000000F)
+#define NT_STATUS_NO_SUCH_GROUP ((nt_status) 0xC0000066)
+#define NT_STATUS_NO_SUCH_LOGON_SESSION ((nt_status) 0xC000005F)
+#define NT_STATUS_NO_SUCH_MEMBER ((nt_status) 0xC000017A)
+#define NT_STATUS_NO_SUCH_PACKAGE ((nt_status) 0xC00000FE)
+#define NT_STATUS_NO_SUCH_PRIVILEGE ((nt_status) 0xC0000060)
+#define NT_STATUS_NO_SUCH_USER ((nt_status) 0xC0000064)
+#define NT_STATUS_NO_TGT_REPLY ((nt_status) 0xC00002EF)
+#define NT_STATUS_NO_TOKEN ((nt_status) 0xC000007C)
+#define NT_STATUS_NO_TRACKING_SERVICE ((nt_status) 0xC000029F)
+#define NT_STATUS_NO_TRUST_LSA_SECRET ((nt_status) 0xC000018A)
+#define NT_STATUS_NO_TRUST_SAM_ACCOUNT ((nt_status) 0xC000018B)
+#define NT_STATUS_NO_TXF_METADATA ((nt_status) 0x80190029)
+#define NT_STATUS_NO_UNICODE_TRANSLATION ((nt_status) 0xC0000717)
+#define NT_STATUS_NO_USER_KEYS ((nt_status) 0xC0000290)
+#define NT_STATUS_NO_USER_SESSION_KEY ((nt_status) 0xC0000202)
+#define NT_STATUS_NO_YIELD_PERFORMED ((nt_status) 0x40000024)
+#define NT_STATUS_NTLM_BLOCKED ((nt_status) 0xC0000418)
+#define NT_STATUS_NT_CROSS_ENCRYPTION_REQUIRED ((nt_status) 0xC000015D)
+#define NT_STATUS_NULL_LM_PASSWORD ((nt_status) 0x4000000D)
+#define NT_STATUS_OBJECTID_EXISTS ((nt_status) 0xC000022B)
+#define NT_STATUS_OBJECTID_NOT_FOUND ((nt_status) 0xC00002F0)
+#define NT_STATUS_OBJECT_NAME_COLLISION ((nt_status) 0xC0000035)
+#define NT_STATUS_OBJECT_NAME_EXISTS ((nt_status) 0x40000000)
+#define NT_STATUS_OBJECT_NAME_INVALID ((nt_status) 0xC0000033)
+#define NT_STATUS_OBJECT_NAME_NOT_FOUND ((nt_status) 0xC0000034)
+#define NT_STATUS_OBJECT_NO_LONGER_EXISTS ((nt_status) 0xC0190021)
+#define NT_STATUS_OBJECT_PATH_INVALID ((nt_status) 0xC0000039)
+#define NT_STATUS_OBJECT_PATH_NOT_FOUND ((nt_status) 0xC000003A)
+#define NT_STATUS_OBJECT_PATH_SYNTAX_BAD ((nt_status) 0xC000003B)
+#define NT_STATUS_OBJECT_TYPE_MISMATCH ((nt_status) 0xC0000024)
+#define NT_STATUS_ONLY_IF_CONNECTED ((nt_status) 0xC00002CC)
+#define NT_STATUS_OPEN_FAILED ((nt_status) 0xC0000136)
+#define NT_STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION ((nt_status) 0xC019005A)
+#define NT_STATUS_OPLOCK_BREAK_IN_PROGRESS ((nt_status) 0x00000108)
+#define NT_STATUS_OPLOCK_NOT_GRANTED ((nt_status) 0xC00000E2)
+#define NT_STATUS_ORDINAL_NOT_FOUND ((nt_status) 0xC0000138)
+#define NT_STATUS_PAGEFILE_CREATE_FAILED ((nt_status) 0xC0000146)
+#define NT_STATUS_PAGEFILE_QUOTA ((nt_status) 0xC0000007)
+#define NT_STATUS_PAGEFILE_QUOTA_EXCEEDED ((nt_status) 0xC000012C)
+#define NT_STATUS_PAGE_FAULT_COPY_ON_WRITE ((nt_status) 0x00000112)
+#define NT_STATUS_PAGE_FAULT_DEMAND_ZERO ((nt_status) 0x00000111)
+#define NT_STATUS_PAGE_FAULT_GUARD_PAGE ((nt_status) 0x00000113)
+#define NT_STATUS_PAGE_FAULT_PAGING_FILE ((nt_status) 0x00000114)
+#define NT_STATUS_PAGE_FAULT_TRANSITION ((nt_status) 0x00000110)
+#define NT_STATUS_PARAMETER_QUOTA_EXCEEDED ((nt_status) 0xC0000410)
+#define NT_STATUS_PARITY_ERROR ((nt_status) 0xC000002B)
+#define NT_STATUS_PARTIAL_COPY ((nt_status) 0x8000000D)
+#define NT_STATUS_PARTITION_FAILURE ((nt_status) 0xC0000172)
+#define NT_STATUS_PASSWORD_EXPIRED ((nt_status) 0xC0000071)
+#define NT_STATUS_PASSWORD_MUST_CHANGE ((nt_status) 0xC0000224)
+#define NT_STATUS_PASSWORD_RESTRICTION ((nt_status) 0xC000006C)
+#define NT_STATUS_PATH_NOT_COVERED ((nt_status) 0xC0000257)
+#define NT_STATUS_PENDING ((nt_status) 0x00000103)
+#define NT_STATUS_PER_USER_TRUST_QUOTA_EXCEEDED ((nt_status) 0xC0000401)
+#define NT_STATUS_PIPE_BROKEN ((nt_status) 0xC000014B)
+#define NT_STATUS_PIPE_BUSY ((nt_status) 0xC00000AE)
+#define NT_STATUS_PIPE_CLOSING ((nt_status) 0xC00000B1)
+#define NT_STATUS_PIPE_CONNECTED ((nt_status) 0xC00000B2)
+#define NT_STATUS_PIPE_DISCONNECTED ((nt_status) 0xC00000B0)
+#define NT_STATUS_PIPE_EMPTY ((nt_status) 0xC00000D9)
+#define NT_STATUS_PIPE_LISTENING ((nt_status) 0xC00000B3)
+#define NT_STATUS_PIPE_NOT_AVAILABLE ((nt_status) 0xC00000AC)
+#define NT_STATUS_PKINIT_CLIENT_FAILURE ((nt_status) 0xC000038C)
+#define NT_STATUS_PKINIT_FAILURE ((nt_status) 0xC0000320)
+#define NT_STATUS_PKINIT_NAME_MISMATCH ((nt_status) 0xC00002F9)
+#define NT_STATUS_PKU2U_CERT_FAILURE ((nt_status) 0xC000042E)
+#define NT_STATUS_PLUGPLAY_NO_DEVICE ((nt_status) 0xC000025E)
+#define NT_STATUS_PLUGPLAY_QUERY_VETOED ((nt_status) 0x80000028)
+#define NT_STATUS_PNP_BAD_MPS_TABLE ((nt_status) 0xC0040035)
+#define NT_STATUS_PNP_INVALID_ID ((nt_status) 0xC0040038)
+#define NT_STATUS_PNP_IRQ_TRANSLATION_FAILED ((nt_status) 0xC0040037)
+#define NT_STATUS_PNP_REBOOT_REQUIRED ((nt_status) 0xC00002D2)
+#define NT_STATUS_PNP_RESTART_ENUMERATION ((nt_status) 0xC00002CE)
+#define NT_STATUS_PNP_TRANSLATION_FAILED ((nt_status) 0xC0040036)
+#define NT_STATUS_POLICY_OBJECT_NOT_FOUND ((nt_status) 0xC000029A)
+#define NT_STATUS_POLICY_ONLY_IN_DS ((nt_status) 0xC000029B)
+#define NT_STATUS_PORT_ALREADY_HAS_COMPLETION_LIST ((nt_status) 0xC000071A)
+#define NT_STATUS_PORT_ALREADY_SET ((nt_status) 0xC0000048)
+#define NT_STATUS_PORT_CLOSED ((nt_status) 0xC0000700)
+#define NT_STATUS_PORT_CONNECTION_REFUSED ((nt_status) 0xC0000041)
+#define NT_STATUS_PORT_DISCONNECTED ((nt_status) 0xC0000037)
+#define NT_STATUS_PORT_MESSAGE_TOO_LONG ((nt_status) 0xC000002F)
+#define NT_STATUS_PORT_NOT_SET ((nt_status) 0xC0000353)
+#define NT_STATUS_PORT_UNREACHABLE ((nt_status) 0xC000023F)
+#define NT_STATUS_POSSIBLE_DEADLOCK ((nt_status) 0xC0000194)
+#define NT_STATUS_POWER_STATE_INVALID ((nt_status) 0xC00002D3)
+#define NT_STATUS_PREDEFINED_HANDLE ((nt_status) 0x40000016)
+#define NT_STATUS_PRENT4_MACHINE_ACCOUNT ((nt_status) 0xC0000357)
+#define NT_STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED ((nt_status) 0x0000010E)
+#define NT_STATUS_PRINT_CANCELLED ((nt_status) 0xC00000C8)
+#define NT_STATUS_PRINT_QUEUE_FULL ((nt_status) 0xC00000C6)
+#define NT_STATUS_PRIVILEGED_INSTRUCTION ((nt_status) 0xC0000096)
+#define NT_STATUS_PRIVILEGE_NOT_HELD ((nt_status) 0xC0000061)
+#define NT_STATUS_PROCEDURE_NOT_FOUND ((nt_status) 0xC000007A)
+#define NT_STATUS_PROCESS_CLONED ((nt_status) 0x00000129)
+#define NT_STATUS_PROCESS_IN_JOB ((nt_status) 0x00000124)
+#define NT_STATUS_PROCESS_IS_PROTECTED ((nt_status) 0xC0000712)
+#define NT_STATUS_PROCESS_IS_TERMINATING ((nt_status) 0xC000010A)
+#define NT_STATUS_PROCESS_NOT_IN_JOB ((nt_status) 0x00000123)
+#define NT_STATUS_PROFILING_AT_LIMIT ((nt_status) 0xC00000D3)
+#define NT_STATUS_PROFILING_NOT_STARTED ((nt_status) 0xC00000B7)
+#define NT_STATUS_PROFILING_NOT_STOPPED ((nt_status) 0xC00000B8)
+#define NT_STATUS_PROPSET_NOT_FOUND ((nt_status) 0xC0000230)
+#define NT_STATUS_PROTOCOL_NOT_SUPPORTED ((nt_status) 0xC000A013)
+#define NT_STATUS_PROTOCOL_UNREACHABLE ((nt_status) 0xC000023E)
+#define NT_STATUS_PTE_CHANGED ((nt_status) 0xC0000434)
+#define NT_STATUS_PURGE_FAILED ((nt_status) 0xC0000435)
+#define NT_STATUS_PWD_HISTORY_CONFLICT ((nt_status) 0xC000025C)
+#define NT_STATUS_PWD_TOO_RECENT ((nt_status) 0xC000025B)
+#define NT_STATUS_PWD_TOO_SHORT ((nt_status) 0xC000025A)
+#define NT_STATUS_QUOTA_EXCEEDED ((nt_status) 0xC0000044)
+#define NT_STATUS_QUOTA_LIST_INCONSISTENT ((nt_status) 0xC0000266)
+#define NT_STATUS_RANGE_LIST_CONFLICT ((nt_status) 0xC0000282)
+#define NT_STATUS_RANGE_NOT_FOUND ((nt_status) 0xC000028C)
+#define NT_STATUS_RANGE_NOT_LOCKED ((nt_status) 0xC000007E)
+#define NT_STATUS_RDP_PROTOCOL_ERROR ((nt_status) 0xC00A0032)
+#define NT_STATUS_RECEIVE_EXPEDITED ((nt_status) 0x40000010)
+#define NT_STATUS_RECEIVE_PARTIAL ((nt_status) 0x4000000F)
+#define NT_STATUS_RECEIVE_PARTIAL_EXPEDITED ((nt_status) 0x40000011)
+#define NT_STATUS_RECOVERY_FAILURE ((nt_status) 0xC0000227)
+#define NT_STATUS_RECOVERY_NOT_NEEDED ((nt_status) 0x40190034)
+#define NT_STATUS_RECURSIVE_DISPATCH ((nt_status) 0xC0000704)
+#define NT_STATUS_REDIRECTOR_HAS_OPEN_HANDLES ((nt_status) 0x80000023)
+#define NT_STATUS_REDIRECTOR_NOT_STARTED ((nt_status) 0xC00000FB)
+#define NT_STATUS_REDIRECTOR_PAUSED ((nt_status) 0xC00000D1)
+#define NT_STATUS_REDIRECTOR_STARTED ((nt_status) 0xC00000FC)
+#define NT_STATUS_REGISTRY_CORRUPT ((nt_status) 0xC000014C)
+#define NT_STATUS_REGISTRY_HIVE_RECOVERED ((nt_status) 0x8000002A)
+#define NT_STATUS_REGISTRY_IO_FAILED ((nt_status) 0xC000014D)
+#define NT_STATUS_REGISTRY_QUOTA_LIMIT ((nt_status) 0xC0000256)
+#define NT_STATUS_REGISTRY_RECOVERED ((nt_status) 0x40000009)
+#define NT_STATUS_REG_NAT_CONSUMPTION ((nt_status) 0xC00002C9)
+#define NT_STATUS_REINITIALIZATION_NEEDED ((nt_status) 0xC0000287)
+#define NT_STATUS_REMOTE_DISCONNECT ((nt_status) 0xC000013C)
+#define NT_STATUS_REMOTE_FILE_VERSION_MISMATCH ((nt_status) 0xC019000C)
+#define NT_STATUS_REMOTE_NOT_LISTENING ((nt_status) 0xC00000BC)
+#define NT_STATUS_REMOTE_RESOURCES ((nt_status) 0xC000013D)
+#define NT_STATUS_REMOTE_SESSION_LIMIT ((nt_status) 0xC0000196)
+#define NT_STATUS_REMOTE_STORAGE_MEDIA_ERROR ((nt_status) 0xC000029E)
+#define NT_STATUS_REMOTE_STORAGE_NOT_ACTIVE ((nt_status) 0xC000029D)
+#define NT_STATUS_REPARSE ((nt_status) 0x00000104)
+#define NT_STATUS_REPARSE_ATTRIBUTE_CONFLICT ((nt_status) 0xC00002B2)
+#define NT_STATUS_REPARSE_OBJECT ((nt_status) 0x00000118)
+#define NT_STATUS_REPARSE_POINT_NOT_RESOLVED ((nt_status) 0xC0000280)
+#define NT_STATUS_REPLY_MESSAGE_MISMATCH ((nt_status) 0xC000021F)
+#define NT_STATUS_REQUEST_ABORTED ((nt_status) 0xC0000240)
+#define NT_STATUS_REQUEST_CANCELED ((nt_status) 0xC0000703)
+#define NT_STATUS_REQUEST_NOT_ACCEPTED ((nt_status) 0xC00000D0)
+#define NT_STATUS_REQUEST_OUT_OF_SEQUENCE ((nt_status) 0xC000042A)
+#define NT_STATUS_RESOURCEMANAGER_NOT_FOUND ((nt_status) 0xC019004F)
+#define NT_STATUS_RESOURCEMANAGER_READ_ONLY ((nt_status) 0x00000202)
+#define NT_STATUS_RESOURCE_DATA_NOT_FOUND ((nt_status) 0xC0000089)
+#define NT_STATUS_RESOURCE_ENUM_USER_STOP ((nt_status) 0xC00B0007)
+#define NT_STATUS_RESOURCE_IN_USE ((nt_status) 0xC0000708)
+#define NT_STATUS_RESOURCE_LANG_NOT_FOUND ((nt_status) 0xC0000204)
+#define NT_STATUS_RESOURCE_NAME_NOT_FOUND ((nt_status) 0xC000008B)
+#define NT_STATUS_RESOURCE_NOT_OWNED ((nt_status) 0xC0000264)
+#define NT_STATUS_RESOURCE_REQUIREMENTS_CHANGED ((nt_status) 0x00000119)
+#define NT_STATUS_RESOURCE_TYPE_NOT_FOUND ((nt_status) 0xC000008A)
+#define NT_STATUS_RESTART_BOOT_APPLICATION ((nt_status) 0xC0000453)
+#define NT_STATUS_RESUME_HIBERNATION ((nt_status) 0x4000002B)
+#define NT_STATUS_RETRY ((nt_status) 0xC000022D)
+#define NT_STATUS_REVISION_MISMATCH ((nt_status) 0xC0000059)
+#define NT_STATUS_REVOCATION_OFFLINE_C ((nt_status) 0xC000038B)
+#define NT_STATUS_REVOCATION_OFFLINE_KDC ((nt_status) 0xC000040C)
+#define NT_STATUS_RM_ALREADY_STARTED ((nt_status) 0x40190035)
+#define NT_STATUS_RM_DISCONNECTED ((nt_status) 0xC0190032)
+#define NT_STATUS_RM_METADATA_CORRUPT ((nt_status) 0xC0190006)
+#define NT_STATUS_RM_NOT_ACTIVE ((nt_status) 0xC0190005)
+#define NT_STATUS_ROLLBACK_TIMER_EXPIRED ((nt_status) 0xC019003C)
+#define NT_STATUS_RXACT_COMMITTED ((nt_status) 0x0000010A)
+#define NT_STATUS_RXACT_COMMIT_FAILURE ((nt_status) 0xC000011D)
+#define NT_STATUS_RXACT_COMMIT_NECESSARY ((nt_status) 0x80000018)
+#define NT_STATUS_RXACT_INVALID_STATE ((nt_status) 0xC000011C)
+#define NT_STATUS_RXACT_STATE_CREATED ((nt_status) 0x40000004)
+#define NT_STATUS_SAM_INIT_FAILURE ((nt_status) 0xC00002E3)
+#define NT_STATUS_SAM_NEED_BOOTKEY_FLOPPY ((nt_status) 0xC00002E0)
+#define NT_STATUS_SAM_NEED_BOOTKEY_PASSWORD ((nt_status) 0xC00002DF)
+#define NT_STATUS_SECRET_TOO_LONG ((nt_status) 0xC0000157)
+#define NT_STATUS_SECTION_NOT_EXTENDED ((nt_status) 0xC0000087)
+#define NT_STATUS_SECTION_NOT_IMAGE ((nt_status) 0xC0000049)
+#define NT_STATUS_SECTION_PROTECTION ((nt_status) 0xC000004E)
+#define NT_STATUS_SECTION_TOO_BIG ((nt_status) 0xC0000040)
+#define NT_STATUS_SECURITY_STREAM_IS_INCONSISTENT ((nt_status) 0xC00001A0)
+#define NT_STATUS_SEGMENT_NOTIFICATION ((nt_status) 0x40000005)
+#define NT_STATUS_SEMAPHORE_LIMIT_EXCEEDED ((nt_status) 0xC0000047)
+#define NT_STATUS_SERIAL_COUNTER_TIMEOUT ((nt_status) 0x4000000C)
+#define NT_STATUS_SERIAL_MORE_WRITES ((nt_status) 0x40000008)
+#define NT_STATUS_SERIAL_NO_DEVICE_INITED ((nt_status) 0xC0000150)
+#define NT_STATUS_SERVER_DISABLED ((nt_status) 0xC0000080)
+#define NT_STATUS_SERVER_HAS_OPEN_HANDLES ((nt_status) 0x80000024)
+#define NT_STATUS_SERVER_NOT_DISABLED ((nt_status) 0xC0000081)
+#define NT_STATUS_SERVER_SHUTDOWN_IN_PROGRESS ((nt_status) 0xC00002FF)
+#define NT_STATUS_SERVER_SID_MISMATCH ((nt_status) 0xC00002A0)
+#define NT_STATUS_SERVICE_NOTIFICATION ((nt_status) 0x40000018)
+#define NT_STATUS_SETMARK_DETECTED ((nt_status) 0x80000021)
+#define NT_STATUS_SHARED_IRQ_BUSY ((nt_status) 0xC000016C)
+#define NT_STATUS_SHARED_POLICY ((nt_status) 0xC0000299)
+#define NT_STATUS_SHARING_PAUSED ((nt_status) 0xC00000CF)
+#define NT_STATUS_SHARING_VIOLATION ((nt_status) 0xC0000043)
+#define NT_STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME ((nt_status) 0xC000019F)
+#define NT_STATUS_SHUTDOWN_IN_PROGRESS ((nt_status) 0xC00002FE)
+#define NT_STATUS_SINGLE_STEP ((nt_status) 0x80000004)
+#define NT_STATUS_SMARTCARD_CARD_BLOCKED ((nt_status) 0xC0000381)
+#define NT_STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED ((nt_status) 0xC0000382)
+#define NT_STATUS_SMARTCARD_CERT_EXPIRED ((nt_status) 0xC000038D)
+#define NT_STATUS_SMARTCARD_CERT_REVOKED ((nt_status) 0xC0000389)
+#define NT_STATUS_SMARTCARD_IO_ERROR ((nt_status) 0xC0000387)
+#define NT_STATUS_SMARTCARD_LOGON_REQUIRED ((nt_status) 0xC00002FA)
+#define NT_STATUS_SMARTCARD_NO_CARD ((nt_status) 0xC0000383)
+#define NT_STATUS_SMARTCARD_NO_CERTIFICATE ((nt_status) 0xC0000385)
+#define NT_STATUS_SMARTCARD_NO_KEYSET ((nt_status) 0xC0000386)
+#define NT_STATUS_SMARTCARD_NO_KEY_CONTAINER ((nt_status) 0xC0000384)
+#define NT_STATUS_SMARTCARD_SILENT_CONTEXT ((nt_status) 0xC000038F)
+#define NT_STATUS_SMARTCARD_SUBSYSTEM_FAILURE ((nt_status) 0xC0000321)
+#define NT_STATUS_SMARTCARD_WRONG_PIN ((nt_status) 0xC0000380)
+#define NT_STATUS_SMI_PRIMITIVE_INSTALLER_FAILED ((nt_status) 0xC0150025)
+#define NT_STATUS_SOME_NOT_MAPPED ((nt_status) 0x00000107)
+#define NT_STATUS_SOURCE_ELEMENT_EMPTY ((nt_status) 0xC0000283)
+#define NT_STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION ((nt_status) 0xC0190049)
+#define NT_STATUS_SPECIAL_ACCOUNT ((nt_status) 0xC0000124)
+#define NT_STATUS_SPECIAL_GROUP ((nt_status) 0xC0000125)
+#define NT_STATUS_SPECIAL_USER ((nt_status) 0xC0000126)
+#define NT_STATUS_STACK_BUFFER_OVERRUN ((nt_status) 0xC0000409)
+#define NT_STATUS_STACK_OVERFLOW ((nt_status) 0xC00000FD)
+#define NT_STATUS_STACK_OVERFLOW_READ ((nt_status) 0xC0000228)
+#define NT_STATUS_STOPPED_ON_SYMLINK ((nt_status) 0x8000002D)
+#define NT_STATUS_STREAM_MINIVERSION_NOT_FOUND ((nt_status) 0xC0190022)
+#define NT_STATUS_STREAM_MINIVERSION_NOT_VALID ((nt_status) 0xC0190023)
+#define NT_STATUS_STRONG_CRYPTO_NOT_SUPPORTED ((nt_status) 0xC00002F6)
+#define NT_STATUS_SUSPEND_COUNT_EXCEEDED ((nt_status) 0xC000004A)
+#define NT_STATUS_SXS_ACTIVATION_CONTEXT_DISABLED ((nt_status) 0xC0150007)
+#define NT_STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT ((nt_status) 0xC015001E)
+#define NT_STATUS_SXS_ASSEMBLY_MISSING ((nt_status) 0xC015000C)
+#define NT_STATUS_SXS_ASSEMBLY_NOT_FOUND ((nt_status) 0xC0150004)
+#define NT_STATUS_SXS_CANT_GEN_ACTCTX ((nt_status) 0xC0150002)
+#define NT_STATUS_SXS_COMPONENT_STORE_CORRUPT ((nt_status) 0xC015001A)
+#define NT_STATUS_SXS_CORRUPTION ((nt_status) 0xC0150015)
+#define NT_STATUS_SXS_CORRUPT_ACTIVATION_STACK ((nt_status) 0xC0150014)
+#define NT_STATUS_SXS_EARLY_DEACTIVATION ((nt_status) 0xC015000F)
+#define NT_STATUS_SXS_FILE_HASH_MISMATCH ((nt_status) 0xC015001B)
+#define NT_STATUS_SXS_FILE_HASH_MISSING ((nt_status) 0xC0150027)
+#define NT_STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY ((nt_status) 0xC015001F)
+#define NT_STATUS_SXS_IDENTITIES_DIFFERENT ((nt_status) 0xC015001D)
+#define NT_STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE ((nt_status) 0xC0150018)
+#define NT_STATUS_SXS_IDENTITY_PARSE_ERROR ((nt_status) 0xC0150019)
+#define NT_STATUS_SXS_INVALID_ACTCTXDATA_FORMAT ((nt_status) 0xC0150003)
+#define NT_STATUS_SXS_INVALID_DEACTIVATION ((nt_status) 0xC0150010)
+#define NT_STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME ((nt_status) 0xC0150017)
+#define NT_STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE ((nt_status) 0xC0150016)
+#define NT_STATUS_SXS_KEY_NOT_FOUND ((nt_status) 0xC0150008)
+#define NT_STATUS_SXS_MANIFEST_FORMAT_ERROR ((nt_status) 0xC0150005)
+#define NT_STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT ((nt_status) 0xC015001C)
+#define NT_STATUS_SXS_MANIFEST_PARSE_ERROR ((nt_status) 0xC0150006)
+#define NT_STATUS_SXS_MANIFEST_TOO_BIG ((nt_status) 0xC0150022)
+#define NT_STATUS_SXS_MULTIPLE_DEACTIVATION ((nt_status) 0xC0150011)
+#define NT_STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET ((nt_status) 0xC015000E)
+#define NT_STATUS_SXS_PROCESS_TERMINATION_REQUESTED ((nt_status) 0xC0150013)
+#define NT_STATUS_SXS_RELEASE_ACTIVATION_CONTEXT ((nt_status) 0x4015000D)
+#define NT_STATUS_SXS_SECTION_NOT_FOUND ((nt_status) 0xC0150001)
+#define NT_STATUS_SXS_SETTING_NOT_REGISTERED ((nt_status) 0xC0150023)
+#define NT_STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY ((nt_status) 0xC0150012)
+#define NT_STATUS_SXS_THREAD_QUERIES_DISABLED ((nt_status) 0xC015000B)
+#define NT_STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE ((nt_status) 0xC0150024)
+#define NT_STATUS_SXS_VERSION_CONFLICT ((nt_status) 0xC0150009)
+#define NT_STATUS_SXS_WRONG_SECTION_TYPE ((nt_status) 0xC015000A)
+#define NT_STATUS_SYMLINK_CLASS_DISABLED ((nt_status) 0xC0000715)
+#define NT_STATUS_SYNCHRONIZATION_REQUIRED ((nt_status) 0xC0000134)
+#define NT_STATUS_SYSTEM_DEVICE_NOT_FOUND ((nt_status) 0xC0000452)
+#define NT_STATUS_SYSTEM_HIVE_TOO_LARGE ((nt_status) 0xC000036E)
+#define NT_STATUS_SYSTEM_IMAGE_BAD_SIGNATURE ((nt_status) 0xC00002D1)
+#define NT_STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION ((nt_status) 0x40000031)
+#define NT_STATUS_SYSTEM_POWERSTATE_TRANSITION ((nt_status) 0x4000002F)
+#define NT_STATUS_SYSTEM_PROCESS_TERMINATED ((nt_status) 0xC000021A)
+#define NT_STATUS_SYSTEM_SHUTDOWN ((nt_status) 0xC00002EB)
+#define NT_STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED ((nt_status) 0xC000070E)
+#define NT_STATUS_THREADPOOL_HANDLE_EXCEPTION ((nt_status) 0xC000070A)
+#define NT_STATUS_THREADPOOL_RELEASED_DURING_OPERATION ((nt_status) 0xC000070F)
+#define NT_STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED ((nt_status) 0xC000070D)
+#define NT_STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED ((nt_status) 0xC000070C)
+#define NT_STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED ((nt_status) 0xC000070B)
+#define NT_STATUS_THREAD_ALREADY_IN_TASK ((nt_status) 0xC0000502)
+#define NT_STATUS_THREAD_IS_TERMINATING ((nt_status) 0xC000004B)
+#define NT_STATUS_THREAD_NOT_IN_PROCESS ((nt_status) 0xC000012A)
+#define NT_STATUS_THREAD_WAS_SUSPENDED ((nt_status) 0x40000001)
+#define NT_STATUS_TIMEOUT ((nt_status) 0x00000102)
+#define NT_STATUS_TIMER_NOT_CANCELED ((nt_status) 0xC000000C)
+#define NT_STATUS_TIMER_RESOLUTION_NOT_SET ((nt_status) 0xC0000245)
+#define NT_STATUS_TIMER_RESUME_IGNORED ((nt_status) 0x40000025)
+#define NT_STATUS_TIME_DIFFERENCE_AT_DC ((nt_status) 0xC0000133)
+#define NT_STATUS_TM_IDENTITY_MISMATCH ((nt_status) 0xC019004A)
+#define NT_STATUS_TM_INITIALIZATION_FAILED ((nt_status) 0xC0190004)
+#define NT_STATUS_TM_VOLATILE ((nt_status) 0xC019003B)
+#define NT_STATUS_TOKEN_ALREADY_IN_USE ((nt_status) 0xC000012B)
+#define NT_STATUS_TOO_LATE ((nt_status) 0xC0000189)
+#define NT_STATUS_TOO_MANY_ADDRESSES ((nt_status) 0xC0000209)
+#define NT_STATUS_TOO_MANY_COMMANDS ((nt_status) 0xC00000C1)
+#define NT_STATUS_TOO_MANY_CONTEXT_IDS ((nt_status) 0xC000015A)
+#define NT_STATUS_TOO_MANY_GUIDS_REQUESTED ((nt_status) 0xC0000082)
+#define NT_STATUS_TOO_MANY_LINKS ((nt_status) 0xC0000265)
+#define NT_STATUS_TOO_MANY_LUIDS_REQUESTED ((nt_status) 0xC0000074)
+#define NT_STATUS_TOO_MANY_NAMES ((nt_status) 0xC00000CD)
+#define NT_STATUS_TOO_MANY_NODES ((nt_status) 0xC000020E)
+#define NT_STATUS_TOO_MANY_OPENED_FILES ((nt_status) 0xC000011F)
+#define NT_STATUS_TOO_MANY_PAGING_FILES ((nt_status) 0xC0000097)
+#define NT_STATUS_TOO_MANY_PRINCIPALS ((nt_status) 0xC00002F7)
+#define NT_STATUS_TOO_MANY_SECRETS ((nt_status) 0xC0000156)
+#define NT_STATUS_TOO_MANY_SESSIONS ((nt_status) 0xC00000CE)
+#define NT_STATUS_TOO_MANY_SIDS ((nt_status) 0xC000017E)
+#define NT_STATUS_TOO_MANY_THREADS ((nt_status) 0xC0000129)
+#define NT_STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE ((nt_status) 0xC0190040)
+#define NT_STATUS_TRANSACTIONAL_CONFLICT ((nt_status) 0xC0190001)
+#define NT_STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED ((nt_status) 0xC019003F)
+#define NT_STATUS_TRANSACTIONMANAGER_NOT_FOUND ((nt_status) 0xC0190051)
+#define NT_STATUS_TRANSACTIONMANAGER_NOT_ONLINE ((nt_status) 0xC0190052)
+#define NT_STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION ((nt_status) 0xC0190053)
+#define NT_STATUS_TRANSACTIONS_NOT_FROZEN ((nt_status) 0xC0190045)
+#define NT_STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE ((nt_status) 0xC019000A)
+#define NT_STATUS_TRANSACTION_ABORTED ((nt_status) 0xC000020F)
+#define NT_STATUS_TRANSACTION_ALREADY_ABORTED ((nt_status) 0xC0190015)
+#define NT_STATUS_TRANSACTION_ALREADY_COMMITTED ((nt_status) 0xC0190016)
+#define NT_STATUS_TRANSACTION_FREEZE_IN_PROGRESS ((nt_status) 0xC0190046)
+#define NT_STATUS_TRANSACTION_INTEGRITY_VIOLATED ((nt_status) 0xC019005B)
+#define NT_STATUS_TRANSACTION_INVALID_ID ((nt_status) 0xC0000214)
+#define NT_STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER ((nt_status) 0xC0190017)
+#define NT_STATUS_TRANSACTION_INVALID_TYPE ((nt_status) 0xC0000215)
+#define NT_STATUS_TRANSACTION_NOT_ACTIVE ((nt_status) 0xC0190003)
+#define NT_STATUS_TRANSACTION_NOT_ENLISTED ((nt_status) 0xC0190061)
+#define NT_STATUS_TRANSACTION_NOT_FOUND ((nt_status) 0xC019004E)
+#define NT_STATUS_TRANSACTION_NOT_JOINED ((nt_status) 0xC0190007)
+#define NT_STATUS_TRANSACTION_NOT_REQUESTED ((nt_status) 0xC0190014)
+#define NT_STATUS_TRANSACTION_NOT_ROOT ((nt_status) 0xC0190054)
+#define NT_STATUS_TRANSACTION_NO_MATCH ((nt_status) 0xC0000212)
+#define NT_STATUS_TRANSACTION_NO_RELEASE ((nt_status) 0xC0000211)
+#define NT_STATUS_TRANSACTION_OBJECT_EXPIRED ((nt_status) 0xC0190055)
+#define NT_STATUS_TRANSACTION_PROPAGATION_FAILED ((nt_status) 0xC0190010)
+#define NT_STATUS_TRANSACTION_RECORD_TOO_LONG ((nt_status) 0xC0190058)
+#define NT_STATUS_TRANSACTION_REQUEST_NOT_VALID ((nt_status) 0xC0190013)
+#define NT_STATUS_TRANSACTION_REQUIRED_PROMOTION ((nt_status) 0xC0190043)
+#define NT_STATUS_TRANSACTION_RESPONDED ((nt_status) 0xC0000213)
+#define NT_STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED ((nt_status) 0xC0190057)
+#define NT_STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET ((nt_status) 0x80190042)
+#define NT_STATUS_TRANSACTION_SUPERIOR_EXISTS ((nt_status) 0xC0190012)
+#define NT_STATUS_TRANSACTION_TIMED_OUT ((nt_status) 0xC0000210)
+#define NT_STATUS_TRANSLATION_COMPLETE ((nt_status) 0x00000120)
+#define NT_STATUS_TRANSPORT_FULL ((nt_status) 0xC00002CA)
+#define NT_STATUS_TRUSTED_DOMAIN_FAILURE ((nt_status) 0xC000018C)
+#define NT_STATUS_TRUSTED_RELATIONSHIP_FAILURE ((nt_status) 0xC000018D)
+#define NT_STATUS_TRUST_FAILURE ((nt_status) 0xC0000190)
+#define NT_STATUS_TS_INCOMPATIBLE_SESSIONS ((nt_status) 0xC00A0039)
+#define NT_STATUS_TXF_ATTRIBUTE_CORRUPT ((nt_status) 0xC019003D)
+#define NT_STATUS_TXF_DIR_NOT_EMPTY ((nt_status) 0xC0190039)
+#define NT_STATUS_TXF_METADATA_ALREADY_PRESENT ((nt_status) 0x80190041)
+#define NT_STATUS_UNABLE_TO_DECOMMIT_VM ((nt_status) 0xC000002C)
+#define NT_STATUS_UNABLE_TO_DELETE_SECTION ((nt_status) 0xC000001B)
+#define NT_STATUS_UNABLE_TO_FREE_VM ((nt_status) 0xC000001A)
+#define NT_STATUS_UNABLE_TO_LOCK_MEDIA ((nt_status) 0xC0000175)
+#define NT_STATUS_UNABLE_TO_UNLOAD_MEDIA ((nt_status) 0xC0000176)
+#define NT_STATUS_UNDEFINED_CHARACTER ((nt_status) 0xC0000163)
+#define NT_STATUS_UNEXPECTED_IO_ERROR ((nt_status) 0xC00000E9)
+#define NT_STATUS_UNEXPECTED_MM_CREATE_ERR ((nt_status) 0xC00000EA)
+#define NT_STATUS_UNEXPECTED_MM_EXTEND_ERR ((nt_status) 0xC00000EC)
+#define NT_STATUS_UNEXPECTED_MM_MAP_ERROR ((nt_status) 0xC00000EB)
+#define NT_STATUS_UNEXPECTED_NETWORK_ERROR ((nt_status) 0xC00000C4)
+#define NT_STATUS_UNFINISHED_CONTEXT_DELETED ((nt_status) 0xC00002EE)
+#define NT_STATUS_UNHANDLED_EXCEPTION ((nt_status) 0xC0000144)
+#define NT_STATUS_UNKNOWN_REVISION ((nt_status) 0xC0000058)
+#define NT_STATUS_UNMAPPABLE_CHARACTER ((nt_status) 0xC0000162)
+#define NT_STATUS_UNRECOGNIZED_MEDIA ((nt_status) 0xC0000014)
+#define NT_STATUS_UNRECOGNIZED_VOLUME ((nt_status) 0xC000014F)
+#define NT_STATUS_UNSUCCESSFUL ((nt_status) 0xC0000001)
+#define NT_STATUS_UNSUPPORTED_COMPRESSION ((nt_status) 0xC000025F)
+#define NT_STATUS_UNSUPPORTED_PREAUTH ((nt_status) 0xC0000351)
+#define NT_STATUS_UNWIND ((nt_status) 0xC0000027)
+#define NT_STATUS_UNWIND_CONSOLIDATE ((nt_status) 0x80000029)
+#define NT_STATUS_USER2USER_REQUIRED ((nt_status) 0xC0000408)
+#define NT_STATUS_USER_APC ((nt_status) 0x000000C0)
+#define NT_STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED ((nt_status) 0xC0000403)
+#define NT_STATUS_USER_EXISTS ((nt_status) 0xC0000063)
+#define NT_STATUS_USER_MAPPED_FILE ((nt_status) 0xC0000243)
+#define NT_STATUS_USER_SESSION_DELETED ((nt_status) 0xC0000203)
+#define NT_STATUS_VALIDATE_CONTINUE ((nt_status) 0xC0000271)
+#define NT_STATUS_VARIABLE_NOT_FOUND ((nt_status) 0xC0000100)
+#define NT_STATUS_VDM_DISALLOWED ((nt_status) 0xC0000414)
+#define NT_STATUS_VDM_HARD_ERROR ((nt_status) 0xC000021D)
+#define NT_STATUS_VERIFIER_STOP ((nt_status) 0xC0000421)
+#define NT_STATUS_VERIFY_REQUIRED ((nt_status) 0x80000016)
+#define NT_STATUS_VHD_CHILD_PARENT_SIZE_MISMATCH ((nt_status) 0xC03A0017)
+#define NT_STATUS_VHD_DIFFERENCING_CHAIN_CYCLE_DETECTED ((nt_status) 0xC03A0018)
+#define NT_STATUS_VHD_DIFFERENCING_CHAIN_ERROR_IN_PARENT ((nt_status) 0xC03A0019)
+#define NT_STATUS_VHD_PARENT_VHD_ACCESS_DENIED ((nt_status) 0xC03A0016)
+#define NT_STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST ((nt_status) 0x401B00EC)
+#define NT_STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD ((nt_status) 0xC01B00EA)
+#define NT_STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED ((nt_status) 0x801B00EB)
+#define NT_STATUS_VIRTDISK_NOT_VIRTUAL_DISK ((nt_status) 0xC03A0015)
+#define NT_STATUS_VIRTDISK_PROVIDER_NOT_FOUND ((nt_status) 0xC03A0014)
+#define NT_STATUS_VIRTUAL_CIRCUIT_CLOSED ((nt_status) 0xC00000D6)
+#define NT_STATUS_VIRUS_DELETED ((nt_status) 0xC0000907)
+#define NT_STATUS_VIRUS_INFECTED ((nt_status) 0xC0000906)
+#define NT_STATUS_VOLMGR_MIRROR_NOT_SUPPORTED ((nt_status) 0xC038005B)
+#define NT_STATUS_VOLMGR_RAID5_NOT_SUPPORTED ((nt_status) 0xC038005C)
+#define NT_STATUS_VOLSNAP_HIBERNATE_READY ((nt_status) 0x00000125)
+#define NT_STATUS_VOLSNAP_PREPARE_HIBERNATE ((nt_status) 0xC0000407)
+#define NT_STATUS_VOLUME_DIRTY ((nt_status) 0xC0000806)
+#define NT_STATUS_VOLUME_DISMOUNTED ((nt_status) 0xC000026E)
+#define NT_STATUS_VOLUME_MOUNTED ((nt_status) 0x00000109)
+#define NT_STATUS_VOLUME_NOT_UPGRADED ((nt_status) 0xC000029C)
+#define NT_STATUS_WAIT_0 ((nt_status) 0x00000000)
+#define NT_STATUS_WAIT_1 ((nt_status) 0x00000001)
+#define NT_STATUS_WAIT_2 ((nt_status) 0x00000002)
+#define NT_STATUS_WAIT_3 ((nt_status) 0x00000003)
+#define NT_STATUS_WAIT_63 ((nt_status) 0x0000003F)
+#define NT_STATUS_WAIT_CAP ((nt_status) 0x00000040)
+#define NT_STATUS_WAIT_FOR_OPLOCK ((nt_status) 0x00000367)
+#define NT_STATUS_WAKE_SYSTEM ((nt_status) 0x40000294)
+#define NT_STATUS_WAKE_SYSTEM_DEBUGGER ((nt_status) 0x80000007)
+#define NT_STATUS_WAS_LOCKED ((nt_status) 0x40000019)
+#define NT_STATUS_WAS_UNLOCKED ((nt_status) 0x40000017)
+#define NT_STATUS_WMI_ALREADY_DISABLED ((nt_status) 0xC0000302)
+#define NT_STATUS_WMI_ALREADY_ENABLED ((nt_status) 0xC0000303)
+#define NT_STATUS_WMI_GUID_DISCONNECTED ((nt_status) 0xC0000301)
+#define NT_STATUS_WMI_GUID_NOT_FOUND ((nt_status) 0xC0000295)
+#define NT_STATUS_WMI_INSTANCE_NOT_FOUND ((nt_status) 0xC0000296)
+#define NT_STATUS_WMI_ITEMID_NOT_FOUND ((nt_status) 0xC0000297)
+#define NT_STATUS_WMI_NOT_SUPPORTED ((nt_status) 0xC00002DD)
+#define NT_STATUS_WMI_READ_ONLY ((nt_status) 0xC00002C6)
+#define NT_STATUS_WMI_SET_FAILURE ((nt_status) 0xC00002C7)
+#define NT_STATUS_WMI_TRY_AGAIN ((nt_status) 0xC0000298)
+#define NT_STATUS_WORKING_SET_LIMIT_RANGE ((nt_status) 0x40000002)
+#define NT_STATUS_WORKING_SET_QUOTA ((nt_status) 0xC00000A1)
+#define NT_STATUS_WOW_ASSERTION ((nt_status) 0xC0009898)
+#define NT_STATUS_WRONG_COMPARTMENT ((nt_status) 0xC000A085)
+#define NT_STATUS_WRONG_CREDENTIAL_HANDLE ((nt_status) 0xC00002F2)
+#define NT_STATUS_WRONG_EFS ((nt_status) 0xC000028F)
+#define NT_STATUS_WRONG_PASSWORD ((nt_status) 0xC000006A)
+#define NT_STATUS_WRONG_PASSWORD_CORE ((nt_status) 0xC0000149)
+#define NT_STATUS_WRONG_VOLUME ((nt_status) 0xC0000012)
+#define NT_STATUS_WX86_BREAKPOINT ((nt_status) 0x4000001F)
+#define NT_STATUS_WX86_CONTINUE ((nt_status) 0x4000001D)
+#define NT_STATUS_WX86_CREATEWX86TIB ((nt_status) 0x40000028)
+#define NT_STATUS_WX86_EXCEPTION_CHAIN ((nt_status) 0x40000022)
+#define NT_STATUS_WX86_EXCEPTION_CONTINUE ((nt_status) 0x40000020)
+#define NT_STATUS_WX86_EXCEPTION_LASTCHANCE ((nt_status) 0x40000021)
+#define NT_STATUS_WX86_FLOAT_STACK_CHECK ((nt_status) 0xC0000270)
+#define NT_STATUS_WX86_INTERNAL_ERROR ((nt_status) 0xC000026F)
+#define NT_STATUS_WX86_SINGLE_STEP ((nt_status) 0x4000001E)
+#define NT_STATUS_WX86_UNSIMULATE ((nt_status) 0x4000001C)
+#define NT_STATUS_XMLDSIG_ERROR ((nt_status) 0xC000A084)
+#define NT_STATUS_XML_ENCODING_MISMATCH ((nt_status) 0xC0150021)
+#define NT_STATUS_XML_PARSE_ERROR ((nt_status) 0xC000A083)
+
+#endif
diff --git a/include/ntapi/nt_string.h b/include/ntapi/nt_string.h
new file mode 100644
index 0000000..93cd1f6
--- /dev/null
+++ b/include/ntapi/nt_string.h
@@ -0,0 +1,143 @@
+#ifndef _NT_STRING_H_
+#define _NT_STRING_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+
+typedef void * __cdecl ntapi_memset(
+ void *dest,
+ int c,
+ size_t count);
+
+
+typedef int __cdecl ntapi_sprintf(
+ char * buffer,
+ const char * format,
+ ...);
+
+
+typedef size_t __cdecl ntapi_strlen(const char * str);
+
+
+typedef size_t __cdecl ntapi_wcslen(const wchar16_t * str);
+
+
+typedef void ntapi_rtl_init_unicode_string(
+ __out nt_unicode_string * str_dest,
+ __in wchar16_t * str_src);
+
+
+/* yes, there exists a reason (but feel free to scold me nonetheless) */
+typedef size_t __cdecl ntapi_tt_string_null_offset_multibyte(
+ __in const char * str);
+
+typedef size_t __cdecl ntapi_tt_string_null_offset_short(
+ __in const int16_t * str);
+
+typedef size_t __cdecl ntapi_tt_string_null_offset_dword(
+ __in const int32_t * str);
+
+typedef size_t __cdecl ntapi_tt_string_null_offset_qword(
+ __in const int64_t * str);
+
+typedef size_t __cdecl ntapi_tt_string_null_offset_ptrsize(
+ __in const intptr_t *str);
+
+typedef void __cdecl ntapi_tt_init_unicode_string_from_utf16(
+ __out nt_unicode_string * str_dest,
+ __in wchar16_t * str_src);
+
+
+typedef void * __cdecl ntapi_tt_aligned_block_memset(
+ __in void * block,
+ __in uintptr_t val,
+ __in size_t bytes);
+
+typedef uintptr_t * __cdecl ntapi_tt_aligned_block_memcpy(
+ __in uintptr_t * dst,
+ __in const uintptr_t * src,
+ __in size_t bytes);
+
+
+typedef wchar16_t * __cdecl ntapi_tt_memcpy_utf16(
+ __in wchar16_t * dst,
+ __in const wchar16_t * src,
+ __in size_t bytes);
+
+
+typedef wchar16_t * __cdecl ntapi_tt_aligned_memcpy_utf16(
+ __in uintptr_t * dst,
+ __in const uintptr_t * src,
+ __in size_t bytes);
+
+
+typedef void * __cdecl ntapi_tt_generic_memset(
+ __in void * dst,
+ __in uintptr_t val,
+ __in size_t bytes);
+
+typedef void * __cdecl ntapi_tt_generic_memcpy(
+ __in void * dst,
+ __in const void * src,
+ __in size_t bytes);
+
+typedef void __fastcall ntapi_tt_uint16_to_hex_utf16(
+ __in uint16_t key,
+ __out wchar16_t * formatted_key);
+
+
+typedef void __fastcall ntapi_tt_uint32_to_hex_utf16(
+ __in uint32_t key,
+ __out wchar16_t * formatted_key);
+
+
+typedef void __fastcall ntapi_tt_uint64_to_hex_utf16(
+ __in uint64_t key,
+ __out wchar16_t * formatted_key);
+
+
+typedef void __fastcall ntapi_tt_uintptr_to_hex_utf16(
+ __in uintptr_t key,
+ __out wchar16_t * formatted_key);
+
+
+typedef int32_t __fastcall ntapi_tt_hex_utf16_to_uint16(
+ __in wchar16_t hex_key_utf16[4],
+ __out uint16_t * key);
+
+
+typedef int32_t __fastcall ntapi_tt_hex_utf16_to_uint32(
+ __in wchar16_t hex_key_utf16[8],
+ __out uint32_t * key);
+
+
+typedef int32_t __fastcall ntapi_tt_hex_utf16_to_uint64(
+ __in wchar16_t hex_key_utf16[16],
+ __out uint64_t * key);
+
+
+typedef int32_t __fastcall ntapi_tt_hex_utf16_to_uintptr(
+ __in wchar16_t hex_key_utf16[],
+ __out uintptr_t * key);
+
+
+typedef void __fastcall ntapi_tt_uint16_to_hex_utf8(
+ __in uint32_t key,
+ __out unsigned char * buffer);
+
+
+typedef void __fastcall ntapi_tt_uint32_to_hex_utf8(
+ __in uint32_t key,
+ __out unsigned char * buffer);
+
+
+typedef void __fastcall ntapi_tt_uint64_to_hex_utf8(
+ __in uint64_t key,
+ __out unsigned char * buffer);
+
+
+typedef void __fastcall ntapi_tt_uintptr_to_hex_utf8(
+ __in uintptr_t key,
+ __out unsigned char * buffer);
+
+#endif
diff --git a/include/ntapi/nt_sync.h b/include/ntapi/nt_sync.h
new file mode 100644
index 0000000..ecf5f0c
--- /dev/null
+++ b/include/ntapi/nt_sync.h
@@ -0,0 +1,428 @@
+#ifndef _NT_SYNC_H_
+#define _NT_SYNC_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+
+typedef enum _nt_wait_type {
+ NT_WAIT_ALL,
+ NT_WAIT_ANY
+} nt_wait_type;
+
+
+typedef enum _nt_timer_type {
+ NT_NOTIFICATION_TIMER,
+ NT_SYNCHRONIZATION_TIMER
+} nt_timer_type;
+
+
+typedef enum _nt_timer_info_class {
+ NT_TIMER_BASIC_INFORMATION
+} nt_timer_info_class;
+
+
+typedef enum _nt_event_type {
+ NT_NOTIFICATION_EVENT,
+ NT_SYNCHRONIZATION_EVENT
+} nt_event_type;
+
+
+typedef enum _nt_event_states {
+ NT_EVENT_NOT_SIGNALED,
+ NT_EVENT_SIGNALED
+} nt_event_states;
+
+
+typedef enum _nt_event_info_class {
+ NT_EVENT_BASIC_INFORMATION
+} nt_event_info_class;
+
+
+typedef enum _nt_semaphore_info_class {
+ NT_SEMAPHORE_BASIC_INFORMATION
+} nt_semaphore_info_class;
+
+
+typedef enum _nt_mutant_info_class {
+ NT_MUTANT_BASIC_INFORMATION
+} nt_mutant_info_class;
+
+
+typedef enum _nt_io_completion_info_class {
+ NT_IO_COMPLETION_BASIC_INFORMATION
+} nt_io_completion_info_class;
+
+
+/* cache block size */
+#define NT_SYNC_BLOCK_SIZE 64
+
+/* timer access bits */
+#define NT_TIMER_QUERY_STATE 0x00000001U
+#define NT_TIMER_MODIFY_STATE 0x00000002U
+#define NT_TIMER_ALL_ACCESS 0x001F0003U
+
+
+/* event access bits */
+#define NT_EVENT_QUERY_STATE 0x00000001U
+#define NT_EVENT_MODIFY_STATE 0x00000002U
+#define NT_EVENT_ALL_ACCESS 0x001F0003U
+
+
+/* semaphore access bits */
+#define NT_SEMAPHORE_QUERY_STATE 0x00000001U
+#define NT_SEMAPHORE_MODIFY_STATE 0x00000002U
+#define NT_SEMAPHORE_ALL_ACCESS 0x001F0003U
+
+
+/* mutant access bits */
+#define NT_MUTANT_QUERY_STATE 0x00000001U
+#define NT_MUTANT_ALL_ACCESS 0x001F0001U
+
+
+/* io completion access bits */
+#define NT_IO_COMPLETION_QUERY_STATE 0x00000001U
+#define NT_IO_COMPLETION_MODIFY_STATE 0x00000002U
+#define NT_IO_COMPLETION_ALL_ACCESS 0x001F0003U
+
+/* alertable threads */
+#define NT_SYNC_NON_ALERTABLE 0x00000000U
+#define NT_SYNC_ALERTABLE 0x00000001U
+
+/* sync block flag bits */
+#define NT_SYNC_BLOCK_YIELD_TO_SERVER 0x00000001U
+
+typedef struct _nt_timer_basic_information {
+ nt_large_integer timer_remaining;
+ int32_t signal_state;
+} nt_timer_basic_information;
+
+
+typedef struct _nt_event_basic_information {
+ nt_event_type event_type;
+ int32_t signal_state;
+} nt_event_basic_information, nt_ebi;
+
+
+typedef struct _nt_semaphore_basic_information {
+ int32_t current_count;
+ int32_t max_count;
+} nt_semaphore_basic_information;
+
+
+typedef struct _nt_mutant_basic_information {
+ int32_t signal_state;
+ int32_t owned;
+ int32_t abandoned;
+} nt_mutant_basic_information;
+
+
+typedef struct _nt_io_completion_basic_information {
+ int32_t signal_state;
+} nt_io_completion_basic_information;
+
+
+typedef union __attr_aligned__(NT_SYNC_BLOCK_SIZE) _nt_sync_block {
+ char cache_line[NT_SYNC_BLOCK_SIZE];
+ struct {
+ int32_t tid;
+ int32_t pid;
+ uint32_t flags;
+ uint32_t srvtid;
+ uint32_t lock_tries;
+ uint32_t ref_cnt;
+ uint32_t busy;
+ int32_t invalid;
+ nt_timeout lock_wait;
+ void * hwait;
+ void * hsignal;
+ void * hserver;
+ };
+} nt_sync_block;
+
+
+typedef void __stdcall nt_timer_apc_routine(
+ void * timer_context,
+ uint32_t timer_low_value,
+ uint32_t timer_high_value);
+
+
+typedef int32_t __stdcall ntapi_zw_wait_for_single_object(
+ __in void * handle,
+ __in int32_t alertable,
+ __in nt_large_integer * timeout __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_signal_and_wait_for_single_object(
+ __in void * handle_to_signal,
+ __in void * handle_to_wait,
+ __in int32_t alertable,
+ __in nt_large_integer * timeout __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_wait_for_multiple_objects(
+ __in uint32_t handle_count,
+ __in void ** handles,
+ __in nt_wait_type wait_type,
+ __in int32_t alertable,
+ __in nt_large_integer * timeout __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_create_timer(
+ __out void ** htimer,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __in nt_timer_type timer_type);
+
+
+typedef int32_t __stdcall ntapi_zw_open_timer(
+ __out void ** htimer,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_cancel_timer(
+ __in void * htimer,
+ __out int32_t * previous_state __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_set_timer(
+ __in void * htimer,
+ __in nt_large_integer * due_time,
+ __in nt_timer_apc_routine * timer_apc_routine __optional,
+ __in void * timer_context,
+ __in int32_t resume,
+ __in int32_t period,
+ __out int32_t * previous_state __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_query_timer(
+ __in void * htimer,
+ __in nt_timer_info_class timer_info_class,
+ __out void * timer_info,
+ __in size_t timer_info_length,
+ __out size_t * returned_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_create_event(
+ __out void ** hevent,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __in nt_event_type event_type,
+ __in int32_t initial_state);
+
+
+typedef int32_t __stdcall ntapi_zw_open_event(
+ __out void ** hevent,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_set_event(
+ __in void * hevent,
+ __out int32_t * previous_state);
+
+
+typedef int32_t __stdcall ntapi_zw_pulse_event(
+ __in void * hevent,
+ __out int32_t * previous_state);
+
+
+typedef int32_t __stdcall ntapi_zw_reset_event(
+ __in void * hevent,
+ __out int32_t * previous_state);
+
+
+typedef int32_t __stdcall ntapi_zw_clear_event(
+ __in void * hevent);
+
+
+typedef int32_t __stdcall ntapi_zw_query_event(
+ __in void * hevent,
+ __in nt_event_info_class event_info_class,
+ __out void * event_info,
+ __in size_t event_info_length,
+ __out size_t * returned_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_create_semaphore(
+ __out void ** hsemaphore,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __in int32_t initial_count,
+ __in int32_t max_count);
+
+
+typedef int32_t __stdcall ntapi_zw_open_semaphore(
+ __out void ** hsemaphore,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_release_semaphore(
+ __in void * hsemaphore,
+ __in int32_t release_count,
+ __out int32_t * previous_count);
+
+
+typedef int32_t __stdcall ntapi_zw_query_semaphore(
+ __in void * hsemaphore,
+ __in nt_semaphore_info_class semaphore_info_class,
+ __out void * semaphore_info,
+ __in size_t semaphore_info_length,
+ __out size_t * returned_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_create_mutant(
+ __out void ** hmutant,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __in int32_t initial_owner);
+
+
+typedef int32_t __stdcall ntapi_zw_open_mutant(
+ __out void ** hmutant,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_release_mutant(
+ __in void * hmutant,
+ __out int32_t * previous_state);
+
+
+typedef int32_t __stdcall ntapi_zw_query_mutant(
+ __in void * hmutant,
+ __in nt_mutant_info_class mutant_info_class,
+ __out void * mutant_info,
+ __in size_t mutant_info_length,
+ __out size_t * returned_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_create_io_completion(
+ __out void ** hio_completion,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __in uint32_t max_concurrent_threads);
+
+
+typedef int32_t __stdcall ntapi_zw_open_io_completion(
+ __out void ** hio_completion,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_set_io_completion(
+ __in void * hio_completion,
+ __in uint32_t completion_key,
+ __in uint32_t completion_value,
+ __in int32_t status,
+ __in uint32_t information);
+
+
+typedef int32_t __stdcall ntapi_zw_remove_io_completion(
+ __in void * hio_completion,
+ __out uint32_t * completion_key,
+ __out uint32_t * completion_value,
+ __out nt_io_status_block * io_status_block,
+ __in nt_large_integer * timeout);
+
+
+typedef int32_t __stdcall ntapi_zw_query_io_completion(
+ __in void * hio_completion,
+ __in nt_io_completion_info_class io_completion_info_class,
+ __out void * io_completion_info,
+ __in size_t io_completion_info_length,
+ __out size_t * returned_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_create_event_pair(
+ __out void ** hevent_pair,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_open_event_pair(
+ __out void ** hevent_pair,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr);
+
+
+typedef int32_t __stdcall ntapi_zw_wait_low_event_pair(
+ __in void * hevent_pair);
+
+
+typedef int32_t __stdcall ntapi_zw_set_low_event_pair(
+ __in void * hevent_pair);
+
+
+typedef int32_t __stdcall ntapi_zw_wait_high_event_pair(
+ __in void * hevent_pair);
+
+
+typedef int32_t __stdcall ntapi_zw_set_high_event_pair(
+ __in void * hevent_pair);
+
+
+typedef int32_t __stdcall ntapi_zw_set_low_wait_high_event_pair(
+ __in void * hevent_pair);
+
+
+typedef int32_t __stdcall ntapi_zw_set_high_wait_low_event_pair(
+ __in void * hevent_pair);
+
+
+/* extensions */
+typedef int32_t __stdcall ntapi_tt_create_inheritable_event(
+ __out void ** hevent,
+ __in nt_event_type event_type,
+ __in int32_t initial_state);
+
+
+typedef int32_t __stdcall ntapi_tt_create_private_event(
+ __out void ** hevent,
+ __in nt_event_type event_type,
+ __in int32_t initial_state);
+
+
+typedef void __stdcall ntapi_tt_sync_block_init(
+ __in nt_sync_block * sync_block,
+ __in uint32_t flags __optional,
+ __in int32_t srvtid __optional,
+ __in int32_t default_lock_tries __optional,
+ __in int64_t default_lock_wait __optional,
+ __in void * hsignal __optional);
+
+
+typedef int32_t __stdcall ntapi_tt_sync_block_lock(
+ __in nt_sync_block * sync_block,
+ __in int32_t lock_tries __optional,
+ __in int64_t lock_wait __optional,
+ __in uint32_t * sig_flag __optional);
+
+
+typedef int32_t __stdcall ntapi_tt_sync_block_server_lock(
+ __in nt_sync_block * sync_block,
+ __in int32_t lock_tries __optional,
+ __in int64_t lock_wait __optional,
+ __in uint32_t * sig_flag __optional);
+
+
+typedef int32_t __stdcall ntapi_tt_sync_block_unlock(
+ __in nt_sync_block * sync_block);
+
+
+typedef void __stdcall ntapi_tt_sync_block_validate(
+ __in nt_sync_block * sync_block);
+
+
+typedef int32_t __stdcall ntapi_tt_sync_block_invalidate(
+ __in nt_sync_block * sync_block);
+
+
+typedef int32_t __stdcall ntapi_tt_sync_block_discard(
+ __in nt_sync_block * sync_block);
+
+
+typedef int32_t __stdcall ntapi_tt_wait_for_dummy_event(void);
+
+#endif
diff --git a/include/ntapi/nt_sysinfo.h b/include/ntapi/nt_sysinfo.h
new file mode 100644
index 0000000..b8266e6
--- /dev/null
+++ b/include/ntapi/nt_sysinfo.h
@@ -0,0 +1,796 @@
+#ifndef _NT_SYSINFO_H_
+#define _NT_SYSINFO_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+#include "nt_memory.h"
+
+typedef enum _nt_system_info_class {
+ NT_SYSTEM_INFORMATION_CLASS_MIN = 0,
+ NT_SYSTEM_BASIC_INFORMATION = 0,
+ NT_SYSTEM_PROCESSOR_INFORMATION = 1,
+ NT_SYSTEM_PERFORMANCE_INFORMATION = 2,
+ NT_SYSTEM_TIME_OF_DAY_INFORMATION = 3,
+ NT_SYSTEM_NOT_IMPLEMENTED1 = 4,
+ NT_SYSTEM_PROCESS_INFORMATION = 5,
+ NT_SYSTEM_CALL_COUNTS = 6,
+ NT_SYSTEM_DEVICE_INFORMATION = 7,
+ NT_SYSTEM_PROCESSOR_TIMES = 8,
+ NT_SYSTEM_GLOBAL_FLAG = 9,
+ NT_SYSTEM_NOT_IMPLEMENTED2 = 10,
+ NT_SYSTEM_CALL_TIME_INFORMATION = 10,
+ NT_SYSTEM_MODULE_INFORMATION = 11,
+ NT_SYSTEM_LOCK_INFORMATION = 12,
+ NT_SYSTEM_NOT_IMPLEMENTED3 = 13,
+ NT_SYSTEM_NOT_IMPLEMENTED4 = 14,
+ NT_SYSTEM_NOT_IMPLEMENTED5 = 15,
+ NT_SYSTEM_HANDLE_INFORMATION = 16,
+ NT_SYSTEM_OBJECT_INFORMATION = 17,
+ NT_SYSTEM_PAGE_FILE_INFORMATION = 18,
+ NT_SYSTEM_INSTRUCTION_EMULATION_COUNTS = 19,
+ NT_SYSTEM_INVALID_INFO_CLASS1 = 20,
+ NT_SYSTEM_CACHE_INFORMATION = 21,
+ NT_SYSTEM_POOL_TAG_INFORMATION = 22,
+ NT_SYSTEM_PROCESSOR_STATISTICS = 23,
+ NT_SYSTEM_DPC_INFORMATION = 24,
+ NT_SYSTEM_NOT_IMPLEMENTED6 = 25,
+ NT_SYSTEM_LOAD_IMAGE = 26,
+ NT_SYSTEM_UNLOAD_IMAGE = 27,
+ NT_SYSTEM_TIME_ADJUSTMENT = 28,
+ NT_SYSTEM_NOT_IMPLEMENTED7 = 29,
+ NT_SYSTEM_NOT_IMPLEMENTED8 = 30,
+ NT_SYSTEM_NOT_IMPLEMENTED9 = 31,
+ NT_SYSTEM_CRASH_DUMP_INFORMATION = 32,
+ NT_SYSTEM_EXCEPTION_INFORMATION = 33,
+ NT_SYSTEM_CRASH_DUMP_STATE_INFORMATION = 34,
+ NT_SYSTEM_KERNEL_DEBUGGER_INFORMATION = 35,
+ NT_SYSTEM_CONTEXT_SWITCH_INFORMATION = 36,
+ NT_SYSTEM_REGISTRY_QUOTA_INFORMATION = 37,
+ NT_SYSTEM_LOAD_AND_CALL_IMAGE = 38,
+ NT_SYSTEM_PRIORITY_SEPARATION = 39,
+ NT_SYSTEM_NOT_IMPLEMENTED10 = 40,
+ NT_SYSTEM_NOT_IMPLEMENTED11 = 41,
+ NT_SYSTEM_INVALID_INFO_CLASS2 = 42,
+ NT_SYSTEM_INVALID_INFO_CLASS3 = 43,
+ NT_SYSTEM_CURRENT_TIME_ZONE_INFORMATION = 44,
+ NT_SYSTEM_TIME_ZONE_INFORMATION = 44,
+ NT_SYSTEM_LOOKASIDE_INFORMATION = 45,
+ NT_SYSTEM_SET_TIME_SLIP_EVENT = 46,
+ NT_SYSTEM_CREATE_SESSION = 47,
+ NT_SYSTEM_DELETE_SESSION = 48,
+ NT_SYSTEM_INVALID_INFO_CLASS4 = 49,
+ NT_SYSTEM_RANGE_START_INFORMATION = 50,
+ NT_SYSTEM_VERIFIER_INFORMATION = 51,
+ NT_SYSTEM_ADD_VERIFIER = 52,
+ NT_SYSTEM_SESSION_PROCESSES_INFORMATION = 53,
+ NT_SYSTEM_INFORMATION_CLASS_MAX
+} nt_system_info_class;
+
+
+typedef enum _nt_thread_state {
+ NT_THREAD_STATE_INITIALIZED = 0,
+ NT_THREAD_STATE_READY = 1,
+ NT_THREAD_STATE_RUNNING = 2,
+ NT_THREAD_STATE_STANDBY = 3,
+ NT_THREAD_STATE_TERMINATED = 4,
+ NT_THREAD_STATE_WAIT = 5,
+ NT_THREAD_STATE_TRANSITION = 6,
+ NT_THREAD_STATE_UNKNOWN = 7
+} nt_thread_state;
+
+
+typedef enum _nt_kwait_reason {
+ NT_KWAIT_EXECUTIVE = 0,
+ NT_KWAIT_FREE_PAGE = 1,
+ NT_KWAIT_PAGE_IN = 2,
+ NT_KWAIT_POOL_ALLOCATION = 3,
+ NT_KWAIT_DELAY_EXECUTION = 4,
+ NT_KWAIT_SUSPENDED = 5,
+ NT_KWAIT_USER_REQUEST = 6,
+ NT_KWAIT_WR_EXECUTIVE = 7,
+ NT_KWAIT_WR_FREE_PAGE = 8,
+ NT_KWAIT_WR_PAGE_IN = 9,
+ NT_KWAIT_WR_POOL_ALLOCATION = 10,
+ NT_KWAIT_WR_DELAY_EXECUTION = 11,
+ NT_KWAIT_WR_SUSPENDED = 12,
+ NT_KWAIT_WR_USER_REQUEST = 13,
+ NT_KWAIT_WR_EVENT_PAIR = 14,
+ NT_KWAIT_WR_QUEUE = 15,
+ NT_KWAIT_WR_LPC_RECEIVE = 16,
+ NT_KWAIT_WR_LPC_REPLY = 17,
+ NT_KWAIT_WR_VIRTUAL_MEMORY = 18,
+ NT_KWAIT_WR_PAGE_OUT = 19,
+ NT_KWAIT_WR_RENDEZVOUS = 20,
+ NT_KWAIT_SPARE2 = 21,
+ NT_KWAIT_SPARE3 = 22,
+ NT_KWAIT_SPARE4 = 23,
+ NT_KWAIT_SPARE5 = 24,
+ NT_KWAIT_WR_CALLOUT_STACK = 25,
+ NT_KWAIT_WR_KERNEL = 26,
+ NT_KWAIT_WR_RESOURCE = 27,
+ NT_KWAIT_WR_PUSH_LOCK = 28,
+ NT_KWAIT_WR_MUTEX = 29,
+ NT_KWAIT_WR_QUANTUM_END = 30,
+ NT_KWAIT_WR_DISPATCH_INT = 31,
+ NT_KWAIT_WR_PREEMPTED = 32,
+ NT_KWAIT_WR_YIELD_EXECUTION = 33,
+ NT_KWAIT_WR_FAST_MUTEX = 34,
+ NT_KWAIT_WR_GUARDED_MUTEX = 35,
+ NT_KWAIT_WR_RUNDOWN = 36,
+ NT_KWAIT_MAXIMUM_WAIT_REASON = 37
+} nt_kwait_reason;
+
+
+typedef enum _nt_pool_type {
+ NT_NON_PAGED_POOL,
+ NT_NON_PAGED_POOL_EXECUTE = 0x0000 + NT_NON_PAGED_POOL,
+ NT_PAGED_POOL,
+ NT_NON_PAGED_POOL_MUST_SUCCEED = 0x0002 + NT_NON_PAGED_POOL,
+ NT_DONT_USE_THIS_TYPE,
+ NT_NON_PAGED_POOL_CACHE_ALIGNED = 0x0004 + NT_NON_PAGED_POOL,
+ NT_PAGED_POOL_CACHE_ALIGNED,
+ NT_NON_PAGED_POOL_CACHE_ALIGNED_MUST_S = 0x0006 + NT_NON_PAGED_POOL,
+ NT_MAX_POOL_TYPE,
+ NT_NON_PAGED_POOL_BASE = 0x0000,
+ NT_NON_PAGED_POOL_BASE_MUST_SUCCEED = 0x0002 + NT_NON_PAGED_POOL_BASE,
+ NT_NON_PAGED_POOL_BASE_CACHE_ALIGNED = 0x0004 + NT_NON_PAGED_POOL_BASE,
+ NT_NON_PAGED_POOL_BASE_CACHE_ALIGNED_MUST_S = 0x0006 + NT_NON_PAGED_POOL_BASE,
+ NT_NON_PAGED_POOL_SESSION = 0x0020,
+ NT_PAGED_POOL_SESSION = 0x0001 + NT_NON_PAGED_POOL_SESSION,
+ NT_NON_PAGED_POOL_MUST_SUCCEED_SESSION = 0x0001 + NT_PAGED_POOL_SESSION,
+ NT_DONT_USE_THIS_TYPE_SESSION = 0x0001 + NT_NON_PAGED_POOL_MUST_SUCCEED_SESSION,
+ NT_NON_PAGED_POOL_CACHE_ALIGNED_SESSION = 0x0001 + NT_DONT_USE_THIS_TYPE_SESSION,
+ NT_PAGED_POOL_CACHE_ALIGNED_SESSION = 0x0001 + NT_NON_PAGED_POOL_CACHE_ALIGNED_SESSION,
+ NT_NON_PAGED_POOL_CACHE_ALIGNED_MUST_S_SESSION = 0x0001 + NT_PAGED_POOL_CACHE_ALIGNED_SESSION,
+ NT_NON_PAGED_POOL_NX = 0x0200,
+ NT_NON_PAGED_POOL_NX_CACHE_ALIGNED = 0x0004 + NT_NON_PAGED_POOL_NX,
+ NT_NON_PAGED_POOL_SESSION_NX = 0x0020 + NT_NON_PAGED_POOL_NX
+} nt_pool_type;
+
+
+typedef enum _nt_shutdown_action {
+ NT_SHUTDOWN_NO_REBOOT,
+ NT_SHUTDOWN_REBOOT,
+ NT_SHUTDOWN_POWER_OFF
+} nt_shutdown_action;
+
+
+typedef enum _nt_debug_control_code {
+ NT_DEBUG_GET_TRACE_INFORMATION = 1,
+ NT_DEBUG_SET_INTERNAL_BREAKPOINT,
+ NT_DEBUG_SET_SPECIAL_CALL,
+ NT_DEBUG_CLEAR_SPECIAL_CALLS,
+ NT_DEBUG_QUERY_SPECIAL_CALLS,
+ NT_DEBUG_DBG_BREAK_POINT,
+ NT_DEBUG_MAXIMUM
+} nt_debug_control_code;
+
+
+
+/* nt_system_global_flag constants */
+#define NT_FLGSTOP_ON_EXCEPTION (uint32_t)0x00000001
+#define NT_FLGSHOW_LDR_SNAPS (uint32_t)0x00000002
+#define NT_FLGDEBUG_INITIAL_COMMAND (uint32_t)0x00000004
+#define NT_FLGSTOP_ON_HUNG_GUI (uint32_t)0x00000008
+#define NT_FLGHEAP_ENABLE_TAIL_CHECK (uint32_t)0x00000010
+#define NT_FLGHEAP_ENABLE_FREE_CHECK (uint32_t)0x00000020
+#define NT_FLGHEAP_VALIDATE_PARAMETERS (uint32_t)0x00000040
+#define NT_FLGHEAP_VALIDATE_ALL (uint32_t)0x00000080
+#define NT_FLGPOOL_ENABLE_TAIL_CHECK (uint32_t)0x00000100
+#define NT_FLGPOOL_ENABLE_FREE_CHECK (uint32_t)0x00000200
+#define NT_FLGPOOL_ENABLE_TAGGING (uint32_t)0x00000400
+#define NT_FLGHEAP_ENABLE_TAGGING (uint32_t)0x00000800
+#define NT_FLGUSER_STACK_TRACE_DB (uint32_t)0x00001000
+#define NT_FLGKERNEL_STACK_TRACE_DB (uint32_t)0x00002000
+#define NT_FLGMAINTAIN_OBJECT_TYPELIST (uint32_t)0x00004000
+#define NT_FLGHEAP_ENABLE_TAG_BY_DLL (uint32_t)0x00008000
+#define NT_FLGIGNORE_DEBUG_PRIV (uint32_t)0x00010000
+#define NT_FLGENABLE_CSRDEBUG (uint32_t)0x00020000
+#define NT_FLGENABLE_KDEBUG_SYMBOL_LOAD (uint32_t)0x00040000
+#define NT_FLGDISABLE_PAGE_KERNEL_STACKS (uint32_t)0x00080000
+#define NT_FLGHEAP_ENABLE_CALL_TRACING (uint32_t)0x00100000
+#define NT_FLGHEAP_DISABLE_COALESCING (uint32_t)0x00200000
+#define NT_FLGENABLE_CLOSE_EXCEPTIONS (uint32_t)0x00400000
+#define NT_FLGENABLE_EXCEPTION_LOGGING (uint32_t)0x00800000
+#define NT_FLGENABLE_DBGPRINT_BUFFERING (uint32_t)0x08000000
+
+/* nt_system_handle_information constants */
+/* FIXME: verify that these values are indeed reversed when compared with the flags returned by zw_query_object */
+#define NT_HANDLE_PROTECT_FROM_CLOSE (unsigned char)0x01
+#define NT_HANDLE_INHERIT (unsigned char)0x02
+
+
+/* nt_system_object flag constants */
+#define NT_FLG_SYSTEM_OBJECT_KERNEL_MODE (uint32_t)0x02
+#define NT_FLG_SYSTEM_OBJECT_CREATOR_INFO (uint32_t)0x04
+#define NT_FLG_SYSTEM_OBJECT_EXCLUSIVE (uint32_t)0x08
+#define NT_FLG_SYSTEM_OBJECT_PERMANENT (uint32_t)0x10
+#define NT_FLG_SYSTEM_OBJECT_DEFAULT_SECURITY_QUOTA (uint32_t)0x20
+#define NT_FLG_SYSTEM_OBJECT_SINGLE_HANDLE_ENTRY (uint32_t)0x40
+
+
+typedef struct _nt_system_information_buffer {
+ size_t count;
+ size_t mark;
+} nt_system_information_buffer;
+
+
+typedef struct _nt_system_information_snapshot {
+ nt_system_information_buffer * buffer;
+ void * pcurrent;
+ size_t info_len;
+ size_t max_len;
+ nt_system_info_class sys_info_class;
+} nt_system_information_snapshot;
+
+
+typedef struct _nt_system_basic_information {
+ uint32_t unknown;
+ uint32_t max_increment;
+ uint32_t physical_page_size;
+ uint32_t physical_page_count;
+ uint32_t physical_page_lowest;
+ uint32_t physical_page_highest;
+ uint32_t allocation_granularity;
+ uint32_t user_address_lowest;
+ uint32_t user_address_highest;
+ uint32_t active_processors;
+ unsigned char processor_count;
+} nt_system_basic_information;
+
+
+typedef struct _nt_system_processor_information {
+ uint16_t processor_architecture;
+ uint16_t processor_level;
+ uint16_t processor_revision;
+ uint16_t unknown;
+ uint32_t feature_bits;
+} nt_system_processor_information;
+
+
+typedef struct _nt_system_performance_information {
+ nt_large_integer idle_time;
+ nt_large_integer read_transfer_count;
+ nt_large_integer write_transfer_count;
+ nt_large_integer other_transfer_count;
+ uint32_t read_operation_count;
+ uint32_t write_operation_count;
+ uint32_t other_operation_count;
+ uint32_t available_pages;
+ uint32_t total_committed_pages;
+ uint32_t total_commit_limit;
+ uint32_t peak_commitment;
+ uint32_t page_faults;
+ uint32_t write_copy_faults;
+ uint32_t transition_faults;
+ uint32_t cache_transition_faults;
+ uint32_t demand_zero_faults;
+ uint32_t pages_read;
+ uint32_t page_read_ios;
+ uint32_t cache_reads;
+ uint32_t cache_ios;
+ uint32_t pagefile_pages_written;
+ uint32_t pagefile_page_write_ios;
+ uint32_t mapped_file_pages_written;
+ uint32_t mapped_file_page_write_ios;
+ uint32_t paged_pool_usage;
+ uint32_t non_paged_pool_usage;
+ uint32_t paged_pool_allocs;
+ uint32_t paged_pool_frees;
+ uint32_t non_paged_pool_allocs;
+ uint32_t non_paged_pool_frees;
+ uint32_t total_free_system_ptes;
+ uint32_t system_code_page;
+ uint32_t total_system_driver_pages;
+ uint32_t total_system_code_pages;
+ uint32_t small_non_paged_lookaside_list_allocate_hits;
+ uint32_t small_paged_lookaside_list_allocate_hits;
+ uint32_t reserved3;
+ uint32_t mm_system_cache_page;
+ uint32_t paged_pool_page;
+ uint32_t system_driver_page;
+ uint32_t fast_read_no_wait;
+ uint32_t fast_read_wait;
+ uint32_t fast_read_resource_miss;
+ uint32_t fast_read_not_possible;
+ uint32_t fast_mdl_read_no_wait;
+ uint32_t fast_mdl_read_wait;
+ uint32_t fast_mdl_read_resource_miss;
+ uint32_t fast_mdl_read_not_possible;
+ uint32_t map_data_no_wait;
+ uint32_t map_data_wait;
+ uint32_t map_data_no_wait_miss;
+ uint32_t map_data_wait_miss;
+ uint32_t pin_mapped_data_count;
+ uint32_t pin_read_no_wait;
+ uint32_t pin_read_wait;
+ uint32_t pin_read_no_wait_miss;
+ uint32_t pin_read_wait_miss;
+ uint32_t copy_read_no_wait;
+ uint32_t copy_read_wait;
+ uint32_t copy_read_no_wait_miss;
+ uint32_t copy_read_wait_miss;
+ uint32_t mdl_read_no_wait;
+ uint32_t mdl_read_wait;
+ uint32_t mdl_read_no_wait_miss;
+ uint32_t mdl_read_wait_miss;
+ uint32_t read_ahead_ios;
+ uint32_t lazy_write_ios;
+ uint32_t lazy_write_pages;
+ uint32_t data_flushes;
+ uint32_t data_pages;
+ uint32_t context_switches;
+ uint32_t first_level_tb_fills;
+ uint32_t second_level_tb_fills;
+ uint32_t system_calls;
+} nt_system_performance_information;
+
+
+typedef struct _nt_system_time_of_day_information {
+ nt_large_integer boot_time;
+ nt_large_integer current_time;
+ nt_large_integer time_zone_bias;
+ uint32_t current_time_zone_id;
+} nt_system_time_of_day_information;
+
+
+typedef struct _nt_system_threads {
+ nt_large_integer kernel_time;
+ nt_large_integer user_time;
+ nt_large_integer create_time;
+ uint32_t wait_time;
+ void * start_address;
+ nt_client_id client_id;
+ uint32_t priority;
+ uint32_t base_priority;
+ uint32_t context_switch_count;
+ nt_thread_state state;
+ nt_kwait_reason wait_reason;
+} nt_system_threads;
+
+
+typedef struct _nt_system_processes {
+ uint32_t next_entry_delta;
+ uint32_t thread_count;
+ uint32_t reserved_1st[6];
+ nt_large_integer create_time;
+ nt_large_integer user_time;
+ nt_large_integer kernel_time;
+ nt_unicode_string process_name;
+ uint32_t base_priority;
+ uint32_t process_id;
+ uint32_t inherited_from_process_id;
+ uint32_t handle_count;
+ uint32_t reserved_2nd[2];
+ nt_vm_counters vm_counters;
+ nt_io_counters io_counters;
+ nt_system_threads threads[];
+} nt_system_processes;
+
+
+typedef struct _nt_syscall_information {
+ uint32_t size;
+ uint32_t number_of_descriptor_tables;
+ uint32_t number_of_routines_in_table[1];
+ uint32_t syscall_counts[];
+} nt_syscall_information;
+
+
+typedef struct _nt_system_configuration_information {
+ uint32_t disk_count;
+ uint32_t floppy_count;
+ uint32_t cd_rom_count;
+ uint32_t tape_count;
+ uint32_t serial_count;
+ uint32_t parallel_count;
+} nt_system_configuration_information;
+
+
+typedef struct _nt_system_process_times {
+ nt_large_integer idle_time;
+ nt_large_integer kernel_time;
+ nt_large_integer user_time;
+ nt_large_integer dpc_time;
+ nt_large_integer interrupt_time;
+ uint32_t interrupt_count;
+} nt_system_process_times;
+
+
+typedef struct _nt_system_global_flag {
+ uint32_t global_flag;
+} nt_system_global_flag;
+
+
+typedef struct _nt_system_module_information {
+ uint32_t reserved_1st;
+ uint32_t reserved_2nd;
+ void * base;
+ uint32_t size;
+ uint32_t flags;
+ uint16_t index;
+ uint16_t unknown;
+ uint16_t load_count;
+ uint16_t path_length;
+ char image_name[256];
+} nt_system_module_information_entry;
+
+
+typedef struct _nt_system_lock_information {
+ void * address;
+ uint16_t type;
+ uint16_t reserved_1st;
+ uint32_t exclusive_owner_thread_id;
+ uint32_t active_count;
+ uint32_t contention_count;
+ uint32_t reserved_2nd;
+ uint32_t reserved_3rd;
+ uint32_t number_of_shared_waiters;
+ uint32_t number_of_exclusive_waiters;
+} nt_system_lock_information;
+
+
+typedef struct _nt_system_handle_information {
+ uint32_t process_id;
+ unsigned char object_type_number;
+ unsigned char flags;
+ uint16_t handle;
+ void * object;
+ uint32_t granted_access;
+#if defined (__NT64)
+ uint32_t granted_access_padding;
+#endif
+} nt_system_handle_information;
+
+
+typedef struct _nt_object_type_information {
+ nt_unicode_string name;
+ uint32_t object_count;
+ uint32_t handle_count;
+ uint32_t reserved1[4];
+ uint32_t peak_object_count;
+ uint32_t peak_handle_count;
+ uint32_t reserved2[4];
+ uint32_t invalid_attributes;
+ nt_generic_mapping generic_mapping;
+ uint32_t valid_access;
+ unsigned char unknown;
+ unsigned char maintain_handle_database;
+ nt_pool_type pool_type;
+ uint32_t paged_pool_usage;
+ uint32_t non_paged_pool_usage;
+} nt_object_type_information, nt_oti;
+
+
+typedef struct _nt_system_object_type_information {
+ uint32_t next_entry_offset;
+ uint32_t object_count;
+ uint32_t handle_count;
+ uint32_t type_number;
+ uint32_t invalid_attributes;
+ nt_generic_mapping generic_mapping;
+ uint32_t valid_access_mask;
+ unsigned char pool_type;
+ unsigned char unknown;
+ nt_unicode_string name;
+} nt_system_object_type_information;
+
+
+typedef struct _nt_system_object_information {
+ uint32_t next_entry_offset;
+ void * object;
+ uint32_t creator_process_id;
+ uint16_t unknown;
+ uint16_t flags;
+ uint32_t pointer_count;
+ uint32_t handle_count;
+ uint32_t paged_pool_usage;
+ uint32_t non_paged_pool_usage;
+ uint32_t exclusive_process_id;
+ nt_security_descriptor *security_descriptor;
+ nt_unicode_string name;
+} nt_system_object_information;
+
+
+typedef struct _nt_system_pagefile_information {
+ uint32_t next_entry_offset;
+ uint32_t current_size;
+ uint32_t total_used;
+ uint32_t peak_used;
+ nt_unicode_string file_name;
+} nt_system_pagefile_information;
+
+
+typedef struct _nt_system_instruction_emulation_information {
+ uint32_t segment_not_present;
+ uint32_t two_byte_opcode;
+ uint32_t es_prefix;
+ uint32_t cs_prefix;
+ uint32_t ss_prefix;
+ uint32_t ds_prefix;
+ uint32_t fs_Prefix;
+ uint32_t gs_prefix;
+ uint32_t oper32_prefix;
+ uint32_t addr32_prefix;
+ uint32_t insb;
+ uint32_t insw;
+ uint32_t outsb;
+ uint32_t outsw;
+ uint32_t pushfd;
+ uint32_t popfd;
+ uint32_t int_nn;
+ uint32_t into;
+ uint32_t iretd;
+ uint32_t inb_imm;
+ uint32_t inw_imm;
+ uint32_t outb_imm;
+ uint32_t outw_imm;
+ uint32_t inb;
+ uint32_t inw;
+ uint32_t outb;
+ uint32_t outw;
+ uint32_t lock_prefix;
+ uint32_t repne_prefix;
+ uint32_t rep_prefix;
+ uint32_t hlt;
+ uint32_t cli;
+ uint32_t sti;
+ uint32_t generic_invalid_opcode;
+} nt_system_instruction_emulation_information;
+
+
+typedef struct _nt_system_pool_tag_information {
+ char tag[4];
+ uint32_t paged_pool_allocs;
+ uint32_t paged_pool_frees;
+ uint32_t paged_pool_usage;
+ uint32_t non_paged_pool_allocs;
+ uint32_t non_paged_pool_frees;
+ uint32_t non_paged_pool_usage;
+} nt_system_pool_tag_information;
+
+
+typedef struct _nt_system_processor_statistics {
+ uint32_t context_switches;
+ uint32_t dpc_count;
+ uint32_t dpc_request_rate;
+ uint32_t time_increment;
+ uint32_t dpc_bypass_count;
+ uint32_t apc_bypass_count;
+} nt_system_processor_statistics;
+
+
+typedef struct _nt_system_dpc_information {
+ uint32_t reserved;
+ uint32_t maximum_dpc_queue_depth;
+ uint32_t minimum_dpc_rate;
+ uint32_t adjust_dpc_threshold;
+ uint32_t ideal_dpc_rate;
+} nt_system_dpc_information;
+
+
+typedef struct _nt_system_load_image {
+ nt_unicode_string module_name;
+ void * module_base;
+ void * section_pointer;
+ void * entry_point;
+ void * export_directory;
+} nt_system_load_image;
+
+
+typedef struct _nt_system_unload_image {
+ void * module_base;
+} nt_system_unload_image;
+
+
+typedef struct _nt_system_query_time_adjustment {
+ uint32_t time_adjustment;
+ uint32_t maximum_increment;
+ int32_t time_synchronization;
+} nt_system_query_time_adjustment;
+
+
+typedef struct _nt_system_set_time_adjustment {
+ uint32_t time_adjustment;
+ int32_t time_synchronization;
+} nt_system_set_time_adjustment;
+
+
+typedef struct _nt_system_crash_dump_information {
+ void * crash_dump_section_handle;
+ void * unknown;
+} nt_system_crash_dump_information;
+
+
+typedef struct _nt_system_exception_information {
+ uint32_t alignment_fixup_count;
+ uint32_t exception_dispatch_count;
+ uint32_t floating_emulation_count;
+ uint32_t reserved;
+} nt_system_exception_information;
+
+
+typedef struct _nt_system_crash_dump_state_information {
+ uint32_t crash_dump_section_exists;
+ uint32_t unknown;
+} nt_system_crash_dump_state_information;
+
+
+typedef struct _nt_system_kernel_debugger_information {
+ unsigned char debugger_enabled;
+ unsigned char debugger_not_present;
+} nt_system_kernel_debugger_information;
+
+
+typedef struct _nt_system_context_switch_information {
+ uint32_t context_switches;
+ uint32_t context_switch_counters[11];
+} nt_system_context_switch_information;
+
+
+typedef struct _nt_system_registry_quota_information {
+ uint32_t registry_quota;
+ uint32_t registry_quota_in_use;
+ uint32_t paged_pool_size;
+} nt_system_registry_quota_information;
+
+
+typedef struct _nt_system_load_and_call_image {
+ nt_unicode_string module_name;
+} nt_system_load_and_call_image;
+
+
+typedef struct _nt_system_priority_separation {
+ uint32_t priority_separation;
+} nt_system_priority_separation;
+
+
+typedef struct _nt_system_time_zone_information {
+ int32_t bias;
+ wchar16_t standard_name[32];
+ nt_large_integer standard_date;
+ int32_t standard_bias;
+ wchar16_t daylight_name[32];
+ nt_large_integer daylight_date;
+ int32_t daylight_bias;
+} nt_system_time_zone_information;
+
+
+typedef struct _nt_system_lookaside_information {
+ uint16_t depth;
+ uint16_t maximum_depth;
+ uint32_t total_allocates;
+ uint32_t allocate_misses;
+ uint32_t total_frees;
+ uint32_t free_misses;
+ nt_pool_type type;
+ uint32_t tag;
+ uint32_t size;
+} nt_system_lookaside_information;
+
+
+typedef struct _nt_system_set_time_slip_event {
+ void * time_slip_event;
+} nt_system_set_time_slip_event;
+
+
+typedef struct _nt_system_create_session {
+ uint32_t session_id;
+} nt_system_create_session;
+
+
+typedef struct _nt_system_delete_session {
+ uint32_t session_id;
+} nt_system_delete_session;
+
+
+typedef struct _nt_system_range_start_information {
+ void * system_range_start;
+} nt_system_range_start_information;
+
+
+typedef struct _nt_system_session_processes_information {
+ uint32_t session_id;
+ uint32_t buffer_size;
+ void * buffer;
+} nt_system_session_processes_information;
+
+
+typedef struct _nt_system_pool_block {
+ int32_t allocated;
+ uint16_t unknown;
+ uint32_t size;
+ char tag[4];
+} nt_system_pool_block;
+
+
+typedef struct _nt_system_pool_blocks_information {
+ uint32_t pool_size;
+ void * pool_base;
+ uint16_t unknown;
+ uint32_t number_of_blocks;
+ nt_system_pool_block pool_blocks[];
+} nt_system_pool_blocks_information;
+
+
+typedef struct _nt_system_memory_usage {
+ void * name;
+ uint16_t valid;
+ uint16_t standby;
+ uint16_t modified;
+ uint16_t page_tables;
+} nt_system_memory_usage;
+
+
+typedef struct _nt_system_memory_usage_information {
+ uint32_t reserved;
+ void * end_of_data;
+ nt_system_memory_usage memory_usage[];
+} nt_system_memory_usage_information;
+
+
+
+typedef int32_t __stdcall ntapi_zw_query_system_information(
+ __in nt_system_info_class sys_info_class,
+ __in_out void * sys_info,
+ __in size_t sys_info_length,
+ __out size_t * returned_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_set_system_information(
+ __in nt_system_info_class sys_info_class,
+ __in_out void * sys_info,
+ __in uint32_t sys_info_length);
+
+
+typedef int32_t __stdcall ntapi_zw_query_system_environment_value(
+ __in nt_unicode_string * name,
+ __out void * value,
+ __in size_t value_length,
+ __out size_t * returned_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_set_system_environment_value(
+ __in nt_unicode_string * name,
+ __in nt_unicode_string * value);
+
+
+typedef int32_t __stdcall ntapi_zw_shutdown_system(
+ __in nt_shutdown_action action);
+
+
+typedef int32_t __stdcall ntapi_zw_system_debug_control(
+ __in nt_debug_control_code control_code,
+ __in void * input_buffer __optional,
+ __in uint32_t input_buffer_length,
+ __out void * output_buffer __optional,
+ __in uint32_t output_buffer_length,
+ __out uint32_t * returned_length __optional);
+
+/* extension functions */
+typedef int32_t __stdcall ntapi_tt_get_system_directory_native_path(
+ __out nt_mem_sec_name * buffer,
+ __in uint32_t buffer_size,
+ __in wchar16_t * base_name,
+ __in uint32_t base_name_size,
+ __out nt_unicode_string * nt_path __optional);
+
+
+typedef int32_t __stdcall ntapi_tt_get_system_directory_dos_path(
+ __in void * hsysdir __optional,
+ __out wchar16_t * buffer,
+ __in uint32_t buffer_size,
+ __in wchar16_t * base_name,
+ __in uint32_t base_name_size,
+ __out nt_unicode_string * nt_path __optional);
+
+
+typedef int32_t __stdcall ntapi_tt_get_system_directory_handle(
+ __out void ** hsysdir,
+ __out nt_mem_sec_name * buffer __optional,
+ __in uint32_t buffer_size __optional);
+
+
+typedef int32_t __stdcall ntapi_tt_get_system_info_snapshot(
+ __in_out nt_system_information_snapshot * sys_info_snapshot);
+
+#endif
diff --git a/include/ntapi/nt_termios.h b/include/ntapi/nt_termios.h
new file mode 100644
index 0000000..4d381d2
--- /dev/null
+++ b/include/ntapi/nt_termios.h
@@ -0,0 +1,305 @@
+#ifndef _NT_TERMIOS_H_
+#define _NT_TERMIOS_H_
+
+#include <psxtypes/psxtypes.h>
+
+/* tty friendly guids */
+#define TTY_PTM_GUID {0x21b51c45,0x3388,0x4dd9,{0x82,0x9a,0x5b,0x67,0x4e,0x3e,0x31,0x55}}
+#define TTY_PTS_GUID {0xa038ed3e,0x7bcc,0x4a53,{0xb2,0x94,0x01,0xdf,0x87,0xf6,0x94,0x70}}
+#define TTY_DBG_GUID {0x5ad03536,0xde3c,0x451a,{0xa4,0x32,0xf6,0xfd,0x95,0x97,0x5c,0x52}}
+
+/* cc_chars */
+#define TTY_NCCS 32
+
+#define TTY_VINTR 0x00
+#define TTY_VQUIT 0x01
+#define TTY_VERASE 0x02
+#define TTY_VKILL 0x03
+#define TTY_VEOF 0x04
+#define TTY_VTIME 0x05
+#define TTY_VMIN 0x06
+#define TTY_VSWTC 0x07
+#define TTY_VSTART 0x08
+#define TTY_VSTOP 0x09
+#define TTY_VSUSP 0x0a
+#define TTY_VEOL 0x0b
+#define TTY_VREPRINT 0x0c
+#define TTY_VDISCARD 0x0d
+#define TTY_VWERASE 0x0e
+#define TTY_VLNEXT 0x0f
+#define TTY_VEOL2 0x10
+
+/* c_iflag bits */
+#define TTY_IGNBRK 0000001
+#define TTY_BRKINT 0000002
+#define TTY_IGNPAR 0000004
+#define TTY_PARMRK 0000010
+#define TTY_INPCK 0000020
+#define TTY_ISTRIP 0000040
+#define TTY_INLCR 0000100
+#define TTY_IGNCR 0000200
+#define TTY_ICRNL 0000400
+#define TTY_IUCLC 0001000
+#define TTY_IXON 0002000
+#define TTY_IXANY 0004000
+#define TTY_IXOFF 0010000
+#define TTY_IMAXBEL 0020000
+#define TTY_IUTF8 0040000
+
+/* c_oflag bits */
+#define TTY_OPOST 0000001
+#define TTY_OLCUC 0000002
+#define TTY_ONLCR 0000004
+#define TTY_OCRNL 0000010
+#define TTY_ONOCR 0000020
+#define TTY_ONLRET 0000040
+#define TTY_OFILL 0000100
+#define TTY_OFDEL 0000200
+#define TTY_NLDLY 0000400
+#define TTY_NL0 0000000
+#define TTY_NL1 0000400
+#define TTY_CRDLY 0003000
+#define TTY_CR0 0000000
+#define TTY_CR1 0001000
+#define TTY_CR2 0002000
+#define TTY_CR3 0003000
+#define TTY_TABDLY 0014000
+#define TTY_TAB0 0000000
+#define TTY_TAB1 0004000
+#define TTY_TAB2 0010000
+#define TTY_TAB3 0014000
+#define TTY_BSDLY 0020000
+#define TTY_BS0 0000000
+#define TTY_BS1 0020000
+#define TTY_FFDLY 0100000
+#define TTY_FF0 0000000
+#define TTY_FF1 0100000
+
+#define TTY_VTDLY 0040000
+#define TTY_VT0 0000000
+#define TTY_VT1 0040000
+
+/* c_lflag bits */
+#define TTY_ISIG 0000001
+#define TTY_ICANON 0000002
+#define TTY_ECHO 0000010
+#define TTY_ECHOE 0000020
+#define TTY_ECHOK 0000040
+#define TTY_ECHONL 0000100
+#define TTY_NOFLSH 0000200
+#define TTY_TOSTOP 0000400
+#define TTY_IEXTEN 0100000
+
+#define TTY_ECHOCTL 0001000
+#define TTY_ECHOPRT 0002000
+#define TTY_ECHOKE 0004000
+#define TTY_FLUSHO 0010000
+#define TTY_PENDIN 0040000
+
+/* c_cflag bits */
+#define TTY_CBAUD 0010017
+#define TTY_CSIZE 0000060
+#define TTY_CS5 0000000
+#define TTY_CS6 0000020
+#define TTY_CS7 0000040
+#define TTY_CS8 0000060
+#define TTY_CSTOPB 0000100
+#define TTY_CREAD 0000200
+#define TTY_PARENB 0000400
+#define TTY_PARODD 0001000
+#define TTY_HUPCL 0002000
+#define TTY_CLOCAL 0004000
+
+/* control flow */
+#define TTY_TCOOFF 0
+#define TTY_TCOON 1
+#define TTY_TCIOFF 2
+#define TTY_TCION 3
+
+/* flush */
+#define TTY_TCIFLUSH 0
+#define TTY_TCOFLUSH 1
+#define TTY_TCIOFLUSH 2
+
+/* tty ioctl */
+#define TTY_TCSANOW 0
+#define TTY_TCSADRAIN 1
+#define TTY_TCSAFLUSH 2
+
+/* tty ioctl codes */
+#define TTY_TCGETS 0x5401
+#define TTY_TCSETS 0x5402
+#define TTY_TCSETSW 0x5403
+#define TTY_TCSETSF 0x5404
+#define TTY_TCGETA 0x5405
+#define TTY_TCSETA 0x5406
+#define TTY_TCSETAW 0x5407
+#define TTY_TCSETAF 0x5408
+#define TTY_TCSBRK 0x5409
+#define TTY_TCXONC 0x540A
+#define TTY_TCFLSH 0x540B
+#define TTY_TIOCEXCL 0x540C
+#define TTY_TIOCNXCL 0x540D
+#define TTY_TIOCSCTTY 0x540E
+#define TTY_TIOCGPGRP 0x540F
+#define TTY_TIOCSPGRP 0x5410
+#define TTY_TIOCOUTQ 0x5411
+#define TTY_TIOCSTI 0x5412
+#define TTY_TIOCGWINSZ 0x5413
+#define TTY_TIOCSWINSZ 0x5414
+#define TTY_TIOCMGET 0x5415
+#define TTY_TIOCMBIS 0x5416
+#define TTY_TIOCMBIC 0x5417
+#define TTY_TIOCMSET 0x5418
+#define TTY_TIOCGSOFTCAR 0x5419
+#define TTY_TIOCSSOFTCAR 0x541A
+#define TTY_FIONREAD 0x541B
+#define TTY_TIOCINQ FIONREAD
+#define TTY_TIOCLINUX 0x541C
+#define TTY_TIOCCONS 0x541D
+#define TTY_TIOCGSERIAL 0x541E
+#define TTY_TIOCSSERIAL 0x541F
+#define TTY_TIOCPKT 0x5420
+#define TTY_FIONBIO 0x5421
+#define TTY_TIOCNOTTY 0x5422
+#define TTY_TIOCSETD 0x5423
+#define TTY_TIOCGETD 0x5424
+#define TTY_TCSBRKP 0x5425
+#define TTY_TIOCTTYGSTRUCT 0x5426
+#define TTY_TIOCSBRK 0x5427
+#define TTY_TIOCCBRK 0x5428
+#define TTY_TIOCGSID 0x5429
+#define TTY_TIOCGPTN 0x5430
+#define TTY_TIOCSPTLCK 0x5431
+#define TTY_TCGETX 0x5432
+#define TTY_TCSETX 0x5433
+#define TTY_TCSETXF 0x5434
+#define TTY_TCSETXW 0x5435
+
+/* packet mode */
+#define TTY_TIOCPKT_DATA 0x00
+#define TTY_TIOCPKT_FLUSHREAD 0x01
+#define TTY_TIOCPKT_FLUSHWRITE 0x02
+#define TTY_TIOCPKT_STOP 0x04
+#define TTY_TIOCPKT_START 0x08
+#define TTY_TIOCPKT_NOSTOP 0x10
+#define TTY_TIOCPKT_DOSTOP 0x20
+#define TTY_TIOCPKT_IOCTL 0x40
+
+/* transmitter empty */
+#define TTY_TIOCSER_TEMT 0x01
+
+/* baud rate... :-) */
+#define TTY_B0 0000000
+#define TTY_B50 0000001
+#define TTY_B75 0000002
+#define TTY_B110 0000003
+#define TTY_B134 0000004
+#define TTY_B150 0000005
+#define TTY_B200 0000006
+#define TTY_B300 0000007
+#define TTY_B600 0000010
+#define TTY_B1200 0000011
+#define TTY_B1800 0000012
+#define TTY_B2400 0000013
+#define TTY_B4800 0000014
+#define TTY_B9600 0000015
+#define TTY_B19200 0000016
+#define TTY_B38400 0000017
+
+#define TTY_B57600 0010001
+#define TTY_B115200 0010002
+#define TTY_B230400 0010003
+#define TTY_B460800 0010004
+#define TTY_B500000 0010005
+#define TTY_B576000 0010006
+#define TTY_B921600 0010007
+#define TTY_B1000000 0010010
+#define TTY_B1152000 0010011
+#define TTY_B1500000 0010012
+#define TTY_B2000000 0010013
+#define TTY_B2500000 0010014
+#define TTY_B3000000 0010015
+#define TTY_B3500000 0010016
+#define TTY_B4000000 0010017
+
+/* special characters */
+#define TTY_CTRL_AT 0x00
+#define TTY_CTRL_A 0x01
+#define TTY_CTRL_B 0x02
+#define TTY_CTRL_C 0x03
+#define TTY_CTRL_D 0x04
+#define TTY_CTRL_E 0x05
+#define TTY_CTRL_F 0x06
+#define TTY_CTRL_G 0x07
+#define TTY_CTRL_H 0x08
+#define TTY_CTRL_I 0x09
+#define TTY_CTRL_J 0x0a
+#define TTY_CTRL_K 0x0b
+#define TTY_CTRL_L 0x0c
+#define TTY_CTRL_M 0x0d
+#define TTY_CTRL_N 0x0e
+#define TTY_CTRL_O 0x0f
+#define TTY_CTRL_P 0x10
+#define TTY_CTRL_Q 0x11
+#define TTY_CTRL_R 0x12
+#define TTY_CTRL_S 0x13
+#define TTY_CTRL_T 0x14
+#define TTY_CTRL_U 0x15
+#define TTY_CTRL_V 0x16
+#define TTY_CTRL_W 0x17
+#define TTY_CTRL_X 0x18
+#define TTY_CTRL_Y 0x19
+#define TTY_CTRL_Z 0x1a
+#define TTY_CTRL_LBRACKET 0x1b
+#define TTY_CTRL_BSLASH 0x1c
+#define TTY_CTRL_RBRACKET 0x1d
+#define TTY_CTRL_CTRL 0x1e
+#define TTY_CTRL_USCORE 0x1f
+#define TTY_CTRL_QMARK 0x7f
+
+/* tty properties */
+struct tty_termios {
+ uint32_t c_iflag;
+ uint32_t c_oflag;
+ uint32_t c_cflag;
+ uint32_t c_lflag;
+ unsigned char c_line;
+ unsigned char c_cc[TTY_NCCS];
+ uint32_t __c_ispeed;
+ uint32_t __c_ospeed;
+};
+
+
+/* tty window properties */
+struct tty_winsize {
+ uint16_t ws_row;
+ uint16_t ws_col;
+ uint16_t ws_xpixel;
+ uint16_t ws_ypixel;
+};
+
+
+struct tty_winbuffer {
+ uint16_t wb_row;
+ uint16_t wb_col;
+ uint16_t wb_prev_row;
+ uint16_t wb_prev_col;
+};
+
+
+struct tty_winpos {
+ uint16_t wp_x;
+ uint16_t wp_y;
+ uint16_t wp_prev_x;
+ uint16_t wp_prev_y;
+};
+
+
+struct tty_winprops {
+ struct tty_winsize winsize;
+ struct tty_winbuffer winbuffer;
+ struct tty_winpos winpos;
+};
+
+#endif
diff --git a/include/ntapi/nt_thread.h b/include/ntapi/nt_thread.h
new file mode 100644
index 0000000..7e39c96
--- /dev/null
+++ b/include/ntapi/nt_thread.h
@@ -0,0 +1,263 @@
+#ifndef _NT_THREAD_H_
+#define _NT_THREAD_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+#include "bits/i386/nt_thread_i386.h"
+#include "bits/x86_64/nt_thread_x86_64.h"
+
+typedef enum _nt_thread_info_class {
+ NT_THREAD_BASIC_INFORMATION,
+ NT_THREAD_TIMES,
+ NT_THREAD_PRIORITY,
+ NT_THREAD_BASE_PRIORITY,
+ NT_THREAD_AFFINITY_MASK,
+ NT_THREAD_IMPERSONATION_TOKEN,
+ NT_THREAD_DESCRIPTOR_TABLE_ENTRY,
+ NT_THREAD_ENABLE_ALIGNMENT_FAULT_FIXUP,
+ NT_THREAD_EVENT_PAIR,
+ NT_THREAD_QUERY_SET_WIN32_START_ADDRESS,
+ NT_THREAD_ZERO_TLS_CELL,
+ NT_THREAD_PERFORMANCE_COUNT,
+ NT_THREAD_AM_I_LASTNT_THREAD,
+ NT_THREAD_IDEAL_PROCESSOR,
+ NT_THREAD_PRIORITY_BOOST,
+ NT_THREAD_SET_TLS_ARRAY_ADDRESS,
+ NT_THREAD_IS_IO_PENDING,
+ NT_THREAD_HIDE_FROM_DEBUGGER
+} nt_thread_info_class;
+
+typedef enum _nt_exception_disposition {
+ NT_EXCEPTION_CONTINUE_EXECUTION,
+ NT_EXCEPTION_CONTINUE_SEARCH,
+ NT_EXCEPTION_NESTED_EXCEPTION,
+ NT_EXCEPTION_COLLIDED_UNWIND
+} nt_exception_disposition;
+
+
+/* special handles */
+#define NT_CURRENT_THREAD_HANDLE (void *)(uintptr_t)-2
+
+/* thread access bits */
+#define NT_THREAD_TERMINATE 0x00000001
+#define NT_THREAD_SUSPEND_RESUME 0x00000002
+#define NT_THREAD_ALERT 0x00000004 /* fits right in the middle... */
+#define NT_THREAD_GET_CONTEXT 0x00000008
+#define NT_THREAD_SET_CONTEXT 0x00000010
+#define NT_THREAD_SET_INFORMATION 0x00000020
+#define NT_THREAD_QUERY_INFORMATION 0x00000040
+#define NT_THREAD_SET_THREAD_TOKEN 0x00000080
+#define NT_THREAD_IMPERSONATE 0x00000100
+#define NT_THREAD_DIRECT_IMPERSONATION 0x00000200
+#define NT_THREAD_SYNCHRONIZE 0x00100000
+
+#define NT_THREAD_ALL_ACCESS NT_THREAD_TERMINATE \
+ | NT_THREAD_SUSPEND_RESUME \
+ | NT_THREAD_ALERT \
+ | NT_THREAD_GET_CONTEXT \
+ | NT_THREAD_SET_CONTEXT \
+ | NT_THREAD_SET_INFORMATION \
+ | NT_THREAD_QUERY_INFORMATION \
+ | NT_THREAD_SET_THREAD_TOKEN \
+ | NT_THREAD_IMPERSONATE \
+ | NT_THREAD_DIRECT_IMPERSONATION \
+ | NT_THREAD_SYNCHRONIZE
+
+/* library-specific thread creation flags */
+#define NT_THREAD_RUN_IMMEDIATELY 0x00000000
+#define NT_CREATE_SUSPENDED 0x00000004
+#define NT_CREATE_FIRST_THREAD_OF_PROCESS 0x00008000
+#define NT_CREATE_LOCAL_THREAD 0x00010000
+#define NT_STACK_SIZE_PARAM_IS_A_RESERVATION 0x00800000
+#define NT_CLOSE_THREAD_HANDLE 0x01000000
+
+
+/* thread context */
+#define NT_CONTEXT_JUST_EVERYTHING (intptr_t)-1
+
+
+/* source mark: arch-specific code: begin */
+#if defined(__NT32) && defined (__X86_MODEL)
+typedef struct _nt_thread_context_i386 nt_thread_context;
+#elif defined(__NT64) && defined (__X86_64_MODEL)
+typedef nt_mcontext_x86_64_t nt_thread_context;
+typedef nt_mcontext_x86_64_t nt_mcontext_t;
+#endif
+/* source mark: arch-specific code: end */
+
+
+typedef struct _nt_user_stack {
+ void * fixed_stack_base;
+ void * fixed_stack_limit;
+ void * expandable_stack_base;
+ void * expandable_stack_limit;
+ void * expandable_stack_bottom;
+} nt_user_stack;
+
+
+typedef struct _nt_exception_registration_record {
+ struct _nt_exception_registration_record * next;
+ nt_exception_disposition * handler;
+} nt_exception_registration_record;
+
+
+typedef struct _nt_tib {
+ nt_exception_registration_record * exception_list;
+ void * stack_base;
+ void * stack_limit;
+ void * sub_system_tib;
+
+ union {
+ void * fiber_data;
+ uint32_t version;
+ };
+
+ void * arbitrary_user_pointer;
+ struct _nt_tib * self;
+} nt_tib;
+
+
+typedef struct _nt_thread_basic_information {
+ int32_t exit_status;
+ nt_tib * teb_base_address;
+ nt_client_id cid;
+ intptr_t affinity_mask;
+ int32_t priority;
+ int32_t base_priority;
+} nt_thread_basic_information;
+
+
+typedef int32_t __stdcall nt_thread_start_routine(void * context);
+
+
+typedef struct _nt_thread_params {
+ __in void * hprocess;
+ __out void * hthread;
+ __in nt_thread_start_routine * start;
+ __in void * arg __optional;
+ __in void * ext_ctx __optional;
+ __in size_t ext_ctx_size;
+ __in nt_object_attributes * obj_attr __optional;
+ __in uint32_t creation_flags;
+ __in uint32_t stack_zero_bits;
+ __in size_t stack_size_commit;
+ __in size_t stack_size_reserve;
+ __in nt_user_stack * stack_info __optional;
+ __in nt_thread_context * reg_context __optional;
+ __out int32_t csrss_status;
+ __out uint32_t thread_id;
+ __in void * reserved[2];
+} nt_thread_params;
+
+
+typedef void __stdcall nt_knormal_routine(
+ void * apc_context,
+ void * arg_1st,
+ void * arg_2nd);
+
+
+typedef int32_t __stdcall ntapi_zw_create_thread(
+ __out void ** hthread,
+ __in uintptr_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __in void * hprocess,
+ __out nt_client_id * hclient_id,
+ __in nt_thread_context * context,
+ __in nt_user_stack * user_stack,
+ __in uintptr_t suspended_flag);
+
+
+typedef int32_t __stdcall ntapi_zw_open_thread(
+ __out void ** hthread,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __in nt_client_id * hclient_id);
+
+
+typedef int32_t __stdcall ntapi_zw_terminate_thread(
+ __in void * hthread,
+ __in int32_t exit_status);
+
+
+typedef int32_t __stdcall ntapi_zw_query_information_thread(
+ __in void * hthread,
+ __in nt_thread_info_class thread_info_class,
+ __out void * thread_info,
+ __in size_t thread_info_length,
+ __out size_t * returned_length __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_set_information_thread(
+ __in void * hthread,
+ __in nt_thread_info_class thread_info_class,
+ __in void * thread_info,
+ __in size_t thread_info_length);
+
+
+typedef int32_t __stdcall ntapi_zw_suspend_thread(
+ __in void * hthread,
+ __out uint32_t * prev_suspend_count __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_resume_thread(
+ __in void * hthread,
+ __out uint32_t * prev_suspend_count __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_get_context_thread(
+ __in void * hthread,
+ __out void * context);
+
+
+typedef int32_t __stdcall ntapi_zw_set_context_thread(
+ __in void * hthread,
+ __in void * context);
+
+
+typedef int32_t __stdcall ntapi_zw_queue_apc_thread(
+ __in void * hthread,
+ __in nt_knormal_routine * apc_routine,
+ __in void * apc_context,
+ __in void * arg_1st,
+ __in void * arg_2nd);
+
+
+typedef int32_t __stdcall ntapi_zw_test_alert(void);
+
+
+typedef int32_t __stdcall ntapi_zw_alert_thread(
+ __in void * hthread);
+
+
+typedef int32_t __stdcall ntapi_zw_alert_resume_thread(
+ __in void * hthread,
+ __out uint32_t * prev_suspend_count __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_register_thread_terminate_port(
+ __in void * port_handle);
+
+
+typedef int32_t __stdcall ntapi_zw_impersonate_thread(
+ __in void * hthread,
+ __in void * target_thread_handle,
+ __in nt_security_quality_of_service * sec_qos);
+
+
+typedef int32_t __stdcall ntapi_zw_impersonate_anonymous_token(
+ __in void * hthread);
+
+
+/* extension functions */
+typedef int32_t __stdcall ntapi_tt_create_local_thread(
+ __in_out nt_thread_params * params);
+
+
+typedef int32_t __stdcall ntapi_tt_create_remote_thread(
+ __in_out nt_thread_params * params);
+
+
+typedef int32_t __stdcall ntapi_tt_create_thread(
+ __in_out nt_thread_params * params);
+
+#endif
diff --git a/include/ntapi/nt_time.h b/include/ntapi/nt_time.h
new file mode 100644
index 0000000..b8ddd41
--- /dev/null
+++ b/include/ntapi/nt_time.h
@@ -0,0 +1,45 @@
+#ifndef _NT_TIME_H_
+#define _NT_TIME_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+
+typedef struct _nt_itimerval {
+ nt_timeout interval;
+ nt_timeout value;
+} nt_itimerval;
+
+typedef int32_t __stdcall ntapi_zw_query_system_time(
+ __out nt_large_integer * current_time);
+
+
+typedef int32_t __stdcall ntapi_zw_set_system_time(
+ __in nt_large_integer * new_time,
+ __out nt_large_integer * old_time __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_query_performance_counter(
+ __out nt_large_integer * performance_count,
+ __out nt_large_integer * performance_frequency __optional);
+
+
+typedef int32_t __stdcall ntapi_zw_set_timer_resolution(
+ __in uint32_t requested_resolution,
+ __in int32_t set,
+ __out uint32_t * actual_resolution);
+
+
+typedef int32_t __stdcall ntapi_zw_query_timer_resolution(
+ __out uint32_t * coarsest_resolution,
+ __out uint32_t * finest_resolution,
+ __out uint32_t * actual_resolution);
+
+
+typedef int32_t __stdcall ntapi_zw_delay_execution(
+ __in int32_t * alertable,
+ __in nt_large_integer * interval);
+
+typedef int32_t __stdcall ntapi_zw_yield_execution(void);
+
+
+#endif
diff --git a/include/ntapi/nt_token.h b/include/ntapi/nt_token.h
new file mode 100644
index 0000000..aa2df2c
--- /dev/null
+++ b/include/ntapi/nt_token.h
@@ -0,0 +1,161 @@
+#ifndef _NT_TOKEN_H_
+#define _NT_TOKEN_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+
+typedef enum _nt_token_type {
+ NT_TOKEN_PRIMARY = 1,
+ NT_TOKEN_IMPERSONATION = 2,
+} nt_token_type;
+
+
+typedef enum _nt_token_info_class {
+ NT_TOKEN_USER = 1,
+ NT_TOKEN_GROUPS = 2,
+ NT_TOKEN_PRIVILEGES = 3,
+ NT_TOKEN_OWNER = 4,
+ NT_TOKEN_PRIMARY_GROUP = 5,
+ NT_TOKEN_DEFAULT_DACL = 6,
+ NT_TOKEN_SOURCE = 7,
+ NT_TOKEN_TYPE = 8,
+ NT_TOKEN_IMPERSONATION_LEVEL = 9,
+ NT_TOKEN_STATISTICS = 10,
+ NT_TOKEN_RESTRICTED_SIDS = 11,
+ NT_TOKEN_SESSION_ID = 12,
+} nt_token_info_class;
+
+
+/* token access bits */
+#define NT_TOKEN_ASSIGN_PRIMARY 0x00000001U
+#define NT_TOKEN_DUPLICATE 0x00000002U
+#define NT_TOKEN_IMPERSONATE 0x00000004U
+#define NT_TOKEN_QUERY 0x00000008U
+#define NT_TOKEN_QUERY_SOURCE 0x00000010U
+#define NT_TOKEN_ADJUST_PRIVILEGES 0x00000020U
+#define NT_TOKEN_ADJUST_GROUPS 0x00000040U
+#define NT_TOKEN_ADJUST_DEFAULT 0x00000080U
+#define NT_TOKEN_ADJUST_SESSIONID 0x00000100U
+
+#define NT_TOKEN_ALL_ACCESS NT_SEC_STANDARD_RIGHTS_REQUIRED \
+ | NT_TOKEN_ASSIGN_PRIMARY \
+ | NT_TOKEN_DUPLICATE \
+ | NT_TOKEN_IMPERSONATE \
+ | NT_TOKEN_QUERY \
+ | NT_TOKEN_QUERY_SOURCE \
+ | NT_TOKEN_ADJUST_PRIVILEGES \
+ | NT_TOKEN_ADJUST_GROUPS \
+ | NT_TOKEN_ADJUST_SESSIONID \
+ | NT_TOKEN_ADJUST_DEFAULT
+
+
+#define NT_TOKEN_READ NT_SEC_STANDARD_RIGHTS_READ \
+ | NT_TOKEN_QUERY
+
+
+#define NT_TOKEN_WRITE NT_SEC_STANDARD_RIGHTS_WRITE \
+ | TOKEN_ADJUST_PRIVILEGES \
+ | NT_OKEN_ADJUST_GROUPS \
+ | NT_TOKEN_ADJUST_DEFAULT
+
+#define NT_TOKEN_EXECUTE NT_SEC_STANDARD_RIGHTS_EXECUTE
+
+
+/* filtered token flags */
+#define NT_DISABLE_MAX_PRIVILEGE 0x01
+
+
+typedef struct _nt_token_statistics {
+ nt_luid token_id;
+ nt_luid authentication_id;
+ nt_large_integer expiration_time;
+ nt_token_type token_type;
+ nt_security_impersonation_level impersonation_level;
+ uint32_t dynamic_charged;
+ uint32_t dynamic_available;
+ uint32_t group_count;
+ uint32_t privilege_count;
+ nt_luid modified_id;
+} nt_token_statistics;
+
+
+typedef int32_t __stdcall ntapi_zw_create_token(
+ __out void ** htoken,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __in nt_token_type type,
+ __in nt_luid * authentication_id,
+ __in nt_large_integer * expiration_time,
+ __in nt_token_user * user,
+ __in nt_token_groups * groups,
+ __in nt_token_privileges * privileges,
+ __in nt_token_owner * owner,
+ __in nt_token_primary_group * primary_group,
+ __in nt_token_default_dacl * default_dacl,
+ __in nt_token_source * source);
+
+
+typedef int32_t __stdcall ntapi_zw_open_process_token(
+ __in void * hprocess,
+ __in uint32_t desired_access,
+ __out void ** htoken);
+
+
+typedef int32_t __stdcall ntapi_zw_open_thread_token(
+ __in void * hthread,
+ __in uint32_t desired_access,
+ __in int32_t open_as_self,
+ __out void ** htoken);
+
+
+typedef int32_t __stdcall ntapi_zw_duplicate_token(
+ __in void * htoken_existing,
+ __in uint32_t desired_access,
+ __in nt_object_attributes * obj_attr,
+ __in int32_t effective_only,
+ __in nt_token_type token_type,
+ __out void ** htoken_new);
+
+
+typedef int32_t __stdcall ntapi_zw_filter_token(
+ __in void * htoken_existing,
+ __in uint32_t flags,
+ __in nt_token_groups * sids_to_disable,
+ __in nt_token_privileges * privileges_to_delete,
+ __in nt_token_groups * sids_to_restrict,
+ __out void ** htoken_new);
+
+
+typedef int32_t __stdcall ntapi_zw_adjust_privileges_token(
+ __in void * htoken,
+ __in int32_t disable_all_privileges,
+ __in nt_token_privileges * new_state,
+ __in size_t buffer_length,
+ __in nt_token_privileges * prev_state __optional,
+ __out size_t * returned_length);
+
+
+typedef int32_t __stdcall ntapi_zw_adjust_groups_token(
+ __in void * htoken,
+ __in int32_t reset_to_default,
+ __in nt_token_groups * new_state,
+ __in size_t buffer_length,
+ __in nt_token_groups * prev_state __optional,
+ __out size_t * returned_length);
+
+
+typedef int32_t __stdcall ntapi_zw_query_information_token(
+ __in void * htoken,
+ __in nt_token_info_class token_info_class,
+ __out void * token_info,
+ __in size_t token_info_length,
+ __out size_t * returned_length);
+
+
+typedef int32_t __stdcall ntapi_zw_set_information_token(
+ __in void * htoken,
+ __in nt_token_info_class token_info_class,
+ __in void * token_info,
+ __in size_t token_info_length);
+
+#endif
diff --git a/include/ntapi/nt_tty.h b/include/ntapi/nt_tty.h
new file mode 100644
index 0000000..4783eb6
--- /dev/null
+++ b/include/ntapi/nt_tty.h
@@ -0,0 +1,438 @@
+#ifndef _NT_TTY_H_
+#define _NT_TTY_H_
+
+/**
+ * tty api:
+ * -----------
+ * this header describes the tty interfaces that are used
+ * by native applications and libraries to communicate with
+ * ntctty, the project's native subsystem and pty server.
+**/
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+#include "nt_port.h"
+#include "nt_termios.h"
+
+typedef enum _nt_tty_opcode {
+ NT_TTY_CLIENT_OPCODE_BASE = 0x40000,
+ /* primary connection */
+ NT_TTY_CLIENT_SESSION_CONNECT = NT_TTY_CLIENT_OPCODE_BASE,
+ NT_TTY_CLIENT_SESSION_DISCONNECT,
+ NT_TTY_CLIENT_SESSION_QUERY,
+ NT_TTY_CLIENT_SESSION_SET,
+ /* process registration */
+ NT_TTY_CLIENT_PROCESS_REGISTER,
+ NT_TTY_CLIENT_PROCESS_UNREGISTER,
+ /* session information */
+ NT_TTY_QUERY_INFORMATION_SERVER,
+ NT_TTY_QUERY_INFORMATION_SESSION,
+ NT_TTY_QUERY_INFORMATION_PROCESS,
+ NT_TTY_QUERY_INFORMATION_THREAD,
+ NT_TTY_QUERY_INFORMATION_SECTION,
+ NT_TTY_QUERY_INFORMATION_PTY,
+ /* peer daemon calls */
+ NT_TTY_REQUEST_PEER,
+ NT_TTY_SIGNAL_PEER,
+ /* pty */
+ NT_TTY_PTY_OPEN,
+ NT_TTY_PTY_CLOSE,
+ NT_TTY_PTY_READ,
+ NT_TTY_PTY_WRITE,
+ NT_TTY_PTY_QUERY,
+ NT_TTY_PTY_SET,
+ NT_TTY_PTY_FCNTL,
+ NT_TTY_PTY_IOCTL,
+ NT_TTY_PTY_CANCEL,
+ NT_TTY_PTY_PEEK,
+ /* virtual mount system */
+ NT_TTY_VMS_QUERY,
+ NT_TTY_VMS_REQUEST,
+ /* exclusive upper limit */
+ NT_TTY_CLIENT_OPCODE_CAP
+} nt_tty_opcode;
+
+
+typedef enum _nt_tty_session_type {
+ NT_TTY_SESSION_PRIMARY,
+ NT_TTY_SESSION_PRIVATE
+} nt_tty_session_type;
+
+
+typedef enum _nt_tty_info_class {
+ NT_TTY_SESSION_INFORMATION,
+ NT_TTY_INFORMATION_CAP
+} nt_tty_info_class;
+
+
+typedef enum _nt_pty_info_class {
+ NT_PTY_BASIC_INFORMATION,
+ NT_PTY_CLIENT_INFORMATION,
+ NT_PTY_INFORMATION_CAP
+} nt_pty_info_class;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_tty_msg_info {
+ uintptr_t msg_id;
+ uint32_t opcode;
+ int32_t status;
+ void * reserved;
+} nt_tty_msg_info;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_tty_register_info {
+ uintptr_t process_id;
+ uintptr_t thread_id;
+ uintptr_t flags;
+ uintptr_t reserved;
+} nt_tty_register_info;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_tty_server_info {
+ nt_port_attr attr;
+ intptr_t pid;
+ intptr_t tid;
+} nt_tty_server_info;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_tty_vms_info {
+ void * hroot;
+ uint32_t hash;
+ uint32_t flags;
+ int64_t key;
+ nt_guid vms_guid;
+ nt_port_keys vms_keys;
+} nt_tty_vms_info;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_tty_peer_info {
+ uint32_t opcode;
+ uint32_t flags;
+ nt_guid service;
+ nt_port_attr peer;
+} nt_tty_peer_info;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_tty_sigctl_info {
+ void * hpty;
+ nt_guid guid;
+ nt_luid luid;
+ uint32_t ctlcode;
+ int32_t cccode;
+ nt_client_id cid;
+ uintptr_t ctxarg[4];
+ struct tty_termios terminfo;
+ struct tty_winsize winsize;
+ nt_iosb iosb;
+} nt_tty_sigctl_info;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_pty_fd_info {
+ void * hpty;
+ void * section;
+ void * section_addr;
+ size_t section_size;
+ nt_guid guid;
+ nt_luid luid;
+ uint32_t access;
+ uint32_t flags;
+ uint32_t share;
+ uint32_t options;
+ intptr_t state;
+ void * hevent[2];
+} nt_pty_fd_info;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_pty_io_info {
+ void * hpty;
+ void * hevent;
+ void * reserved;
+ void * apc_routine;
+ void * apc_context;
+ nt_iosb * riosb;
+ void * raddr;
+ nt_iosb iosb;
+ off_t offset;
+ size_t nbytes;
+ uint32_t key;
+ uint32_t npending;
+ nt_guid guid;
+ nt_luid luid;
+} nt_pty_io_info;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_pty_client_info {
+ uintptr_t any[4];
+} nt_pty_client_info;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_tty_session_info {
+ int32_t pid;
+ int32_t pgid;
+ int32_t sid;
+ int32_t reserved;
+} nt_tty_session_info;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_tty_register_msg {
+ nt_port_message header;
+ struct {
+ nt_tty_msg_info ttyinfo;
+ nt_tty_register_info reginfo;
+ } data;
+} nt_tty_register_msg;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_tty_server_msg {
+ nt_port_message header;
+ struct {
+ nt_tty_msg_info ttyinfo;
+ nt_tty_server_info srvinfo;
+ } data;
+} nt_tty_server_msg;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_tty_vms_msg {
+ nt_port_message header;
+ struct {
+ nt_tty_msg_info ttyinfo;
+ nt_tty_vms_info vmsinfo;
+ } data;
+} nt_tty_vms_msg;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_tty_peer_msg {
+ nt_port_message header;
+ struct {
+ nt_tty_msg_info ttyinfo;
+ nt_tty_peer_info peerinfo;
+ } data;
+} nt_tty_peer_msg;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_pty_fd_msg {
+ nt_port_message header;
+ struct {
+ nt_tty_msg_info ttyinfo;
+ nt_pty_fd_info fdinfo;
+ } data;
+} nt_pty_fd_msg;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_pty_io_msg {
+ nt_port_message header;
+ struct {
+ nt_tty_msg_info ttyinfo;
+ nt_pty_io_info ioinfo;
+ } data;
+} nt_pty_io_msg;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_pty_sigctl_msg {
+ nt_port_message header;
+ struct {
+ nt_tty_msg_info ttyinfo;
+ nt_tty_sigctl_info ctlinfo;
+ } data;
+} nt_pty_sigctl_msg;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_tty_session_msg {
+ nt_port_message header;
+ struct {
+ nt_tty_msg_info ttyinfo;
+ nt_tty_session_info sessioninfo;
+ } data;
+} nt_tty_session_msg;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_tty_port_msg {
+ nt_port_message header;
+ nt_tty_msg_info ttyinfo;
+ union {
+ nt_tty_register_info reginfo;
+ nt_tty_vms_info vmsinfo;
+ nt_tty_peer_info peerinfo;
+ nt_tty_sigctl_info ctlinfo;
+ nt_pty_fd_info fdinfo;
+ nt_pty_io_info ioinfo;
+ nt_pty_client_info clientinfo;
+ nt_tty_session_info sessioninfo;
+ };
+} nt_tty_port_msg;
+
+
+__assert_aligned_size(nt_tty_msg_info, __SIZEOF_POINTER__);
+__assert_aligned_size(nt_tty_register_info, __SIZEOF_POINTER__);
+__assert_aligned_size(nt_tty_vms_info, __SIZEOF_POINTER__);
+__assert_aligned_size(nt_tty_peer_info, __SIZEOF_POINTER__);
+__assert_aligned_size(nt_tty_sigctl_info, __SIZEOF_POINTER__);
+__assert_aligned_size(nt_pty_fd_info, __SIZEOF_POINTER__);
+__assert_aligned_size(nt_pty_io_info, __SIZEOF_POINTER__);
+__assert_aligned_size(nt_tty_register_msg, __SIZEOF_POINTER__);
+__assert_aligned_size(nt_tty_vms_msg, __SIZEOF_POINTER__);
+__assert_aligned_size(nt_tty_peer_msg, __SIZEOF_POINTER__);
+__assert_aligned_size(nt_pty_sigctl_msg, __SIZEOF_POINTER__);
+__assert_aligned_size(nt_pty_fd_msg, __SIZEOF_POINTER__);
+__assert_aligned_size(nt_pty_io_msg, __SIZEOF_POINTER__);
+__assert_aligned_size(nt_tty_port_msg, __SIZEOF_POINTER__);
+
+
+/* tty session */
+typedef int32_t __stdcall ntapi_tty_create_session(
+ __out void ** hport,
+ __out nt_port_name * port_name,
+ __in nt_tty_session_type type,
+ __in const nt_guid * guid __optional,
+ __in wchar16_t * image_name __optional);
+
+
+typedef int32_t __stdcall ntapi_tty_join_session(
+ __out void ** hport,
+ __out nt_port_name * port_name,
+ __in nt_port_attr * port_attr,
+ __in nt_tty_session_type type);
+
+
+typedef int32_t __stdcall ntapi_tty_connect(
+ __out void ** hport,
+ __in wchar16_t * tty_port_name,
+ __in int32_t impersonation_level);
+
+
+typedef int32_t __stdcall ntapi_tty_client_session_query(
+ __in void * hport,
+ __out nt_tty_session_info * sessioninfo);
+
+
+typedef int32_t __stdcall ntapi_tty_client_session_set(
+ __in void * hport,
+ __in nt_tty_session_info * sessioninfo);
+
+
+typedef int32_t __stdcall ntapi_tty_client_process_register(
+ __in void * hport,
+ __in uintptr_t process_id,
+ __in uintptr_t thread_id,
+ __in uintptr_t flags,
+ __in nt_large_integer * reserved);
+
+
+typedef int32_t __stdcall ntapi_tty_query_information_server(
+ __in void * hport,
+ __out nt_tty_server_info * srvinfo);
+
+
+/* pty api */
+typedef struct nt_pty_context nt_pty;
+
+typedef int32_t __stdcall ntapi_pty_open(
+ __in void * hport,
+ __out nt_pty ** pty,
+ __in uint32_t desired_access,
+ __in nt_object_attributes* obj_attr,
+ __out nt_iosb * iosb,
+ __in uint32_t share_access,
+ __in uint32_t open_options);
+
+
+typedef int32_t __stdcall ntapi_pty_reopen(
+ __in void * hport,
+ __in nt_pty * pty);
+
+
+typedef int32_t __stdcall ntapi_pty_close(
+ __in nt_pty * pty);
+
+
+typedef int32_t __stdcall ntapi_pty_read(
+ __in nt_pty * pty,
+ __in void * hevent __optional,
+ __in nt_io_apc_routine * apc_routine __optional,
+ __in void * apc_context __optional,
+ __out nt_iosb * iosb,
+ __out void * buffer,
+ __in uint32_t nbytes,
+ __in nt_large_integer * offset __optional,
+ __in uint32_t * key __optional);
+
+
+typedef int32_t __stdcall ntapi_pty_write(
+ __in nt_pty * pty,
+ __in void * hevent __optional,
+ __in nt_io_apc_routine * apc_routine __optional,
+ __in void * apc_context __optional,
+ __out nt_iosb * iosb,
+ __in void * buffer,
+ __in uint32_t nbytes,
+ __in nt_large_integer * offset __optional,
+ __in uint32_t * key __optional);
+
+
+typedef int32_t __stdcall ntapi_pty_fcntl(
+ __in nt_pty * pty,
+ __in void * hevent __optional,
+ __in nt_io_apc_routine * apc_routine __optional,
+ __in void * apc_context __optional,
+ __out nt_iosb * iosb,
+ __in uint32_t fs_control_code,
+ __in void * input_buffer __optional,
+ __in uint32_t input_buffer_length,
+ __out void * output_buffer __optional,
+ __in uint32_t output_buffer_length);
+
+
+typedef int32_t __stdcall ntapi_pty_ioctl(
+ __in nt_pty * pty,
+ __in void * hevent __optional,
+ __in nt_io_apc_routine * apc_routine __optional,
+ __in void * apc_context __optional,
+ __out nt_iosb * iosb,
+ __in uint32_t io_control_code,
+ __in void * input_buffer __optional,
+ __in uint32_t input_buffer_length,
+ __out void * output_buffer __optional,
+ __in uint32_t output_buffer_length);
+
+
+typedef int32_t __stdcall ntapi_pty_query(
+ __in nt_pty * pty,
+ __out nt_io_status_block * iosb,
+ __out void * pty_info,
+ __in uint32_t pty_info_length,
+ __in nt_pty_info_class pty_info_class);
+
+
+typedef int32_t __stdcall ntapi_pty_set(
+ __in nt_pty * hfile,
+ __out nt_io_status_block * iosb,
+ __in void * pty_info,
+ __in uint32_t pty_info_length,
+ __in nt_pty_info_class pty_info_class);
+
+
+typedef int32_t __stdcall ntapi_pty_cancel(
+ __in nt_pty * pty,
+ __out nt_iosb * iosb);
+
+
+/* peer daemon calls */
+typedef int32_t __stdcall ntapi_tty_request_peer(
+ __in void * hport,
+ __in int32_t opcode,
+ __in uint32_t flags,
+ __in const nt_guid * service,
+ __in nt_port_attr * peer);
+
+
+/* virtual mount system */
+typedef int32_t __stdcall ntapi_tty_vms_query(
+ __in void * hport,
+ __in nt_tty_vms_info * vmsinfo);
+
+
+typedef int32_t __stdcall ntapi_tty_vms_request(
+ __in void * hport,
+ __in nt_tty_vms_info * vmsinfo);
+
+#endif
diff --git a/include/ntapi/nt_unicode.h b/include/ntapi/nt_unicode.h
new file mode 100644
index 0000000..346b744
--- /dev/null
+++ b/include/ntapi/nt_unicode.h
@@ -0,0 +1,146 @@
+#ifndef _NT_UNICODE_H_
+#define _NT_UNICODE_H_
+
+/**
+ * the conversion functions are based on the validation functions;
+ * each of the conversion functions passes its peer validation
+ * function an array of callback handlers, with each member of
+ * the array corresponding to the number of units making the
+ * current code point in utf-8, be that source or destination.
+ * following this logic, then, callback_fn[1] handles 1-byte
+ * code points [00..7F], callback_fn[2] handles 2-byte code
+ * points [C2..DF,80..BF], and so on. the first member of
+ * the array, callback_fn[0], is invoked once the null
+ * termination of the source stream has been reached.
+**/
+
+typedef struct _nt_utf8_callback_args {
+ const unsigned char * src;
+ void * dst;
+ void * dst_cap;
+ uint32_t byte_count;
+ uint32_t code_point;
+ size_t bytes_written;
+} nt_utf8_callback_args;
+
+
+typedef struct _nt_utf16_callback_args {
+ const wchar16_t * src;
+ void * dst;
+ void * dst_cap;
+ uint32_t byte_count;
+ uint32_t code_point;
+ size_t bytes_written;
+} nt_utf16_callback_args;
+
+
+typedef struct _nt_unicode_conversion_params_utf8_to_utf16 {
+ const unsigned char * src;
+ size_t src_size_in_bytes;
+ wchar16_t * dst;
+ size_t dst_size_in_bytes;
+ size_t code_points;
+ size_t bytes_written;
+ void * addr_failed;
+ uintptr_t leftover_count;
+ uintptr_t leftover_bytes;
+} nt_unicode_conversion_params_utf8_to_utf16, nt_strconv_mbtonative;
+
+
+typedef struct _nt_unicode_conversion_params_utf8_to_utf32 {
+ const unsigned char * src;
+ size_t src_size_in_bytes;
+ wchar32_t * dst;
+ size_t dst_size_in_bytes;
+ size_t code_points;
+ size_t bytes_written;
+ void * addr_failed;
+ uintptr_t leftover_count;
+ uintptr_t leftover_bytes;
+} nt_unicode_conversion_params_utf8_to_utf32, nt_strconv_mbtowide;
+
+
+typedef struct _nt_unicode_conversion_params_utf16_to_utf8 {
+ const wchar16_t * src;
+ size_t src_size_in_bytes;
+ unsigned char * dst;
+ size_t dst_size_in_bytes;
+ size_t code_points;
+ size_t bytes_written;
+ void * addr_failed;
+ uintptr_t leftover_count;
+ uintptr_t leftover_bytes;
+} nt_unicode_conversion_params_utf16_to_utf8, nt_strconv_nativetomb;
+
+
+typedef struct _nt_unicode_conversion_params_utf16_to_utf32 {
+ const wchar16_t * src;
+ size_t src_size_in_bytes;
+ wchar32_t * dst;
+ size_t dst_size_in_bytes;
+ size_t code_points;
+ size_t bytes_written;
+ void * addr_failed;
+ uintptr_t leftover_count;
+ uintptr_t leftover_bytes;
+} nt_unicode_conversion_params_utf16_to_utf32, nt_strconv_nativetowide;
+
+__assert_aligned_size(nt_utf8_callback_args,__SIZEOF_POINTER__);
+__assert_aligned_size(nt_utf16_callback_args,__SIZEOF_POINTER__);
+__assert_aligned_size(nt_unicode_conversion_params_utf8_to_utf16,__SIZEOF_POINTER__);
+__assert_aligned_size(nt_unicode_conversion_params_utf8_to_utf32,__SIZEOF_POINTER__);
+__assert_aligned_size(nt_unicode_conversion_params_utf16_to_utf8,__SIZEOF_POINTER__);
+__assert_aligned_size(nt_unicode_conversion_params_utf16_to_utf32,__SIZEOF_POINTER__);
+
+
+typedef int32_t __fastcall ntapi_uc_utf8_callback_fn(
+ __in nt_utf8_callback_args * callback_args);
+
+
+typedef int32_t __fastcall ntapi_uc_utf16_callback_fn(
+ __in nt_utf16_callback_args * callback_args);
+
+
+typedef int32_t __stdcall ntapi_uc_validate_unicode_stream_utf8(
+ __in const unsigned char * ch,
+ __in size_t size_in_bytes __optional,
+ __out size_t * code_points __optional,
+ __out void ** addr_failed __optional,
+ __in ntapi_uc_utf8_callback_fn ** callback_fn __optional,
+ __in nt_utf8_callback_args * callback_args __optional);
+
+
+typedef int32_t __stdcall ntapi_uc_validate_unicode_stream_utf16(
+ __in const wchar16_t * wch,
+ __in size_t size_in_bytes __optional,
+ __out size_t * code_points __optional,
+ __out void ** addr_failed __optional,
+ __in ntapi_uc_utf16_callback_fn ** callback_fn __optional,
+ __in nt_utf16_callback_args * callback_args __optional);
+
+
+typedef int __stdcall ntapi_uc_get_code_point_byte_count_utf8(
+ __in uint32_t code_point);
+
+
+typedef int __stdcall ntapi_uc_get_code_point_byte_count_utf16(
+ __in uint32_t code_point);
+
+
+typedef int32_t __stdcall ntapi_uc_convert_unicode_stream_utf8_to_utf16(
+ __in_out nt_unicode_conversion_params_utf8_to_utf16 * params);
+
+
+typedef int32_t __stdcall ntapi_uc_convert_unicode_stream_utf8_to_utf32(
+ __in_out nt_unicode_conversion_params_utf8_to_utf32 * params);
+
+
+typedef int32_t __stdcall ntapi_uc_convert_unicode_stream_utf16_to_utf8(
+ __in_out nt_unicode_conversion_params_utf16_to_utf8 * params);
+
+
+typedef int32_t __stdcall ntapi_uc_convert_unicode_stream_utf16_to_utf32(
+ __in_out nt_unicode_conversion_params_utf16_to_utf32 * params);
+
+
+#endif
diff --git a/include/ntapi/nt_uuid.h b/include/ntapi/nt_uuid.h
new file mode 100644
index 0000000..c4b4cde
--- /dev/null
+++ b/include/ntapi/nt_uuid.h
@@ -0,0 +1,22 @@
+#ifndef _NT_UUID_H_
+#define _NT_UUID_H_
+
+#include <psxtypes/psxtypes.h>
+#include "nt_object.h"
+
+typedef int32_t __stdcall ntapi_zw_allocate_locally_unique_id(
+ __out nt_luid * luid);
+
+
+/* insufficient for version 4 uuid's */
+typedef int32_t __stdcall ntapi_zw_allocate_uuids(
+ __out nt_large_integer * uuid_last_time_allocated,
+ __out uint32_t * uuid_delta_time,
+ __out uint32_t * uuid_sequence_number,
+ __out unsigned char * uuid_seed);
+
+
+typedef int32_t __stdcall ntapi_zw_set_uuid_seed(
+ __in unsigned char * uuid_seed);
+
+#endif
diff --git a/include/ntapi/nt_vfd.h b/include/ntapi/nt_vfd.h
new file mode 100644
index 0000000..18185aa
--- /dev/null
+++ b/include/ntapi/nt_vfd.h
@@ -0,0 +1,20 @@
+#ifndef _NT_VFD_H_
+#define _NT_VFD_H_
+
+#include <psxtypes/psxtypes.h>
+#include <dalist/dalist.h>
+#include "nt_object.h"
+#include "nt_guid.h"
+
+typedef struct _nt_vfd_dev_name {
+ nt_unicode_string name;
+ wchar16_t prefix[8];
+ nt_guid_str_utf16 guid;
+} nt_vfd_dev_name;
+
+
+typedef void __stdcall ntapi_vfd_dev_name_init(
+ __out nt_vfd_dev_name * devname,
+ __in const nt_guid * guid);
+
+#endif
diff --git a/include/ntapi/nt_vmount.h b/include/ntapi/nt_vmount.h
new file mode 100644
index 0000000..8c5db0c
--- /dev/null
+++ b/include/ntapi/nt_vmount.h
@@ -0,0 +1,329 @@
+#ifndef _NT_VMOUNT_H_
+#define _NT_VMOUNT_H_
+
+#include <psxtypes/psxtypes.h>
+#include <dalist/dalist.h>
+#include "nt_port.h"
+#include "nt_file.h"
+#include "nt_statfs.h"
+#include "nt_tty.h"
+
+/**
+ * vmount api:
+ * -----------
+ * this header provides an api that can be used to
+ * implement a virtual mount system. note, however,
+ * that this library does not (and should not)
+ * provide the server-side implementation of the
+ * system, but only the client-side functionality.
+ * in the larger-scale midipix project, for
+ * instance, a session-wide virtual mount system
+ * is provided by the subsystem ntctty; if you
+ * are writing a free-standing midipix application,
+ * then you may either use the interfaces provided
+ * by ntctty, or roll your own.
+**/
+
+
+/** virtual mount system: concepts
+ * ------------------------------
+ * elements of the virtual mount system are exposed to the
+ * client in terms of offsets from the virtual mount system
+ * base address, rather than absolute pointers. when using
+ * a shared memory section, this allows each client to map
+ * the virtual mount system at an address that is independent
+ * of all other clients. most importantly, clients are only
+ * granted read-only access to the section, and it is hence
+ * impossible for a malformed client to trash the contents
+ * of the virtual mount system.
+ *
+ * to locate information regarding a particular mount point,
+ * the client traverses the virtual mount system using several
+ * numeric keys.
+ *
+ * the server_key member of the virtual mount system structure,
+ * in combination with the node-specific server keys, allow clients
+ * to efficiently use a single ref_counter server call at the end of
+ * the path resolution process.
+ *
+ * in the larger-scale midipix project, the above call fails only when
+ * a referenced mount point has in the meantime become invalid; in other
+ * words, the call shall succeed even if the queried mount point is
+ * no longer found at the top of the target directory stack.
+**/
+
+
+typedef intptr_t nt_vms_offset;
+typedef struct nt_vms_cache_interface * nt_vms_cache;
+
+
+typedef struct _nt_vms_flags {
+ uint16_t rel_depth;
+ uint16_t attr;
+} nt_vms_flags;
+
+typedef struct __attr_ptr_size_aligned__ _nt_vms_point {
+ intptr_t target;
+ intptr_t source;
+ nt_vms_offset parent;
+ nt_vms_offset prev;
+ nt_vms_offset next;
+ int32_t fstype;
+ nt_vms_flags flags;
+ nt_luid luid;
+ intptr_t ref_count;
+ intptr_t server_key;
+ int32_t stack_index;
+ int32_t status;
+ nt_fii fii;
+ uint32_t dev_name_hash;
+ uint16_t dev_name_strlen;
+ uint16_t dev_name_maxlen;
+ nt_vms_offset dev_name;
+ uint32_t end_component_hash;
+ uint16_t end_component_strlen;
+ uint16_t end_component_maxlen;
+ nt_vms_offset end_component;
+ uint32_t src_fstype_hash;
+ uint32_t src_attr;
+ uint32_t src_control_flags;
+ wchar16_t src_drive_letter;
+ wchar16_t src_padding;
+ nt_guid src_volume_guid;
+ nt_fii src_fii;
+ uint32_t src_dev_name_hash;
+ uint32_t reserved;
+} nt_vms_point;
+
+
+typedef struct _nt_vms_node {
+ nt_vms_offset prev;
+ nt_vms_offset next;
+ uint32_t end_component_hash;
+ uint32_t dev_name_hash;
+ nt_large_integer index_number;
+ nt_vms_offset stack;
+} nt_vms_node;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_vms_system {
+ intptr_t client_key;
+ intptr_t server_key;
+ void * hroot;
+ intptr_t vms_points_cap;
+ nt_vms_offset dev_name_head_node; /* dev_name_hash, fii.index_number */
+ nt_vms_offset end_component_head_node; /* end_component_hash, dev_name_hash, fii.index_number */
+} nt_vms_system;
+
+
+typedef enum _nt_vms_opcodes {
+ NT_VMS_CLIENT_OPCODE_BASE = 0x80000,
+ /* virtual mount system daemon opcodes */
+ NT_VMS_CLIENT_CONNECT = NT_VMS_CLIENT_OPCODE_BASE,
+ NT_VMS_CLIENT_DISCONNECT,
+ NT_VMS_CLIENT_UNSHARE,
+ NT_VMS_CLIENT_CONFIG,
+ NT_VMS_POINT_ATTACH,
+ NT_VMS_POINT_DETACH,
+ NT_VMS_POINT_GET_HANDLES,
+ NT_VMS_POINT_GET_VOLINFO,
+ NT_VMS_REF_COUNT_INC,
+ NT_VMS_REF_COUNT_DEC,
+ NT_VMS_TABLE_QUERY,
+ NT_VMS_TABLE_CLONE,
+ /* client opcodes: exclusive upper limit */
+ NT_VMS_CLIENT_OPCODE_CAP
+} nt_vms_opcodes;
+
+typedef struct __attr_ptr_size_aligned__ _nt_vms_msg_info {
+ uintptr_t msg_id;
+ uint32_t opcode;
+ int32_t status;
+ uintptr_t msg_key;
+} nt_vms_msg_info;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_vms_daemon_info {
+ nt_guid daemon_guid;
+ uint32_t srv_pid;
+ uint32_t srv_tid;
+ uint32_t session;
+ uint32_t instance;
+ uint32_t ver_maj;
+ uint32_t ver_min;
+ uint32_t section_size;
+ uint32_t advisory_size;
+ uint32_t points_mounted;
+ uint32_t points_available;
+ void * section_handle;
+} nt_vms_daemon_info;
+
+
+/* attach/detach */
+typedef struct __attr_ptr_size_aligned__ _nt_vms_point_info {
+ nt_vms_point point;
+ nt_fii src_fii;
+ uint32_t src_dev_name_hash;
+ uint32_t src_flags;
+} nt_vms_point_info;
+
+
+/* inc/dec */
+typedef struct __attr_ptr_size_aligned__ _nt_vms_ref_count_info {
+ nt_vms_offset ref_point;
+ nt_luid luid;
+ intptr_t server_key;
+ intptr_t ref_count;
+ nt_fii fii;
+ uint32_t dev_name_hash;
+ int32_t stack_index;
+ void * hsource;
+ void * htarget;
+} nt_vms_ref_count_info;
+
+
+/* query/clone */
+typedef struct __attr_ptr_size_aligned__ _nt_vms_table_info {
+ intptr_t client_key;
+ intptr_t client_section_addr;
+ intptr_t client_section_size;
+ intptr_t reserved;
+} nt_vms_table_info;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_vms_daemon_msg {
+ nt_port_message header;
+ struct {
+ nt_vms_msg_info msginfo;
+
+ union {
+ nt_vms_daemon_info vmsinfo;
+ nt_vms_point_info pointinfo;
+ nt_vms_ref_count_info refcntinfo;
+ };
+ } data;
+} nt_vms_daemon_msg;
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_vms_port_msg {
+ nt_port_message header;
+ nt_vms_msg_info msginfo;
+
+ union {
+ nt_vms_daemon_info vmsinfo;
+ nt_vms_point_info pointinfo;
+ nt_vms_ref_count_info refcntinfo;
+ };
+} nt_vms_port_msg;
+
+
+/* vms helper functions */
+typedef nt_vms_node * __stdcall ntapi_vms_get_end_component_first_node(
+ __in nt_vms_system * pvms_sys,
+ __in uint32_t end_component_hash);
+
+
+typedef nt_vms_node * __stdcall ntapi_vms_get_node_by_dev_name(
+ __in nt_vms_system * pvms_sys,
+ __in uint32_t dev_name_hash,
+ __in nt_large_integer index_number);
+
+
+typedef nt_vms_node * __stdcall ntapi_vms_get_node_by_end_component(
+ __in nt_vms_system * pvms_sys,
+ __in uint32_t end_component_hash,
+ __in uint32_t dev_name_hash,
+ __in nt_large_integer index_number);
+
+
+typedef nt_vms_point * __stdcall ntapi_vms_get_top_of_stack_mount_point(
+ __in nt_vms_system * pvms_sys,
+ __in nt_vms_node * node);
+
+
+/* vms optional cache functions */
+typedef nt_vms_cache __stdcall ntapi_vms_cache_alloc(
+ __in nt_vms_system * vms_sys,
+ __in uint32_t flags __reserved,
+ __in void * options __reserved,
+ __out int32_t * status __optional);
+
+
+typedef int32_t __stdcall ntapi_vms_cache_free(
+ __in nt_vms_cache cache);
+
+
+typedef int32_t __stdcall ntapi_vms_cache_record_append(
+ __in nt_vms_cache cache,
+ __in void * hfile,
+ __in uint32_t dev_name_hash,
+ __in nt_large_integer index_number,
+ __in intptr_t client_key,
+ __in intptr_t server_key);
+
+
+typedef int32_t __stdcall ntapi_vms_cache_record_remove(
+ __in nt_vms_cache cache,
+ __in void * hfile);
+
+
+/* vms server calls */
+typedef int32_t __stdcall ntapi_vms_client_connect(
+ __out void ** hvms,
+ __in nt_tty_vms_info * vmsinfo);
+
+
+typedef int32_t __stdcall ntapi_vms_client_disconnect(
+ __in void * hvms);
+
+
+typedef int32_t __stdcall ntapi_vms_client_unshare(
+ __in void * hvms,
+ __out nt_tty_vms_info * vmsinfo);
+
+
+typedef int32_t __stdcall ntapi_vms_client_config(
+ __in void * hvms);
+
+
+typedef int32_t __stdcall ntapi_vms_point_attach(
+ __in void * hvms,
+ __in nt_vms_point_info * point_info);
+
+
+typedef int32_t __stdcall ntapi_vms_point_detach(
+ __in void * hvms,
+ __in nt_vms_ref_count_info * ref_cnt_info);
+
+
+typedef int32_t __stdcall ntapi_vms_point_get_handles(
+ __in void * hvms,
+ __in nt_vms_ref_count_info * ref_cnt_info);
+
+
+typedef int32_t __stdcall ntapi_vms_point_get_volinfo(
+ __in void * hvms,
+ __in nt_vms_point_info * point_info);
+
+
+typedef int32_t __stdcall ntapi_vms_ref_count_inc(
+ __in void * hvms,
+ __in nt_vms_ref_count_info * ref_cnt_info);
+
+
+typedef int32_t __stdcall ntapi_vms_ref_count_dec(
+ __in void * hvms,
+ __in nt_vms_ref_count_info * ref_cnt_info);
+
+
+typedef int32_t __stdcall ntapi_vms_table_query(
+ __in void * hvms,
+ __in nt_vms_daemon_info * vms_info);
+
+
+typedef int32_t __stdcall ntapi_vms_table_clone(
+ __in void * hvms,
+ __in nt_vms_daemon_info * vms_info);
+
+
+#endif
diff --git a/include/ntapi/ntapi.h b/include/ntapi/ntapi.h
new file mode 100644
index 0000000..7978786
--- /dev/null
+++ b/include/ntapi/ntapi.h
@@ -0,0 +1,596 @@
+#ifndef _NTAPI_H_
+#define _NTAPI_H_
+
+#if defined (NTAPI_BUILD)
+#define __ntapi_api __attr_export__
+#elif defined (NTAPI_SHARED)
+#define __ntapi_api __attr_import__
+#elif defined (NTAPI_STATIC)
+#define __ntapi_api
+#else
+#define __ntapi_api
+#endif
+
+#include <psxtypes/psxtypes.h>
+#include "nt_status.h"
+#include "nt_crc32.h"
+#include "nt_object.h"
+#include "nt_sysinfo.h"
+#include "nt_memory.h"
+#include "nt_section.h"
+#include "nt_thread.h"
+#include "nt_process.h"
+#include "nt_job.h"
+#include "nt_token.h"
+#include "nt_sync.h"
+#include "nt_time.h"
+#include "nt_profiling.h"
+#include "nt_port.h"
+#include "nt_device.h"
+#include "nt_file.h"
+#include "nt_registry.h"
+#include "nt_security.h"
+#include "nt_pnp.h"
+#include "nt_exception.h"
+#include "nt_locale.h"
+#include "nt_uuid.h"
+#include "nt_atom.h"
+#include "nt_os.h"
+#include "nt_ipc.h"
+#include "nt_ldr.h"
+#include "nt_string.h"
+#include "nt_guid.h"
+#include "nt_argv.h"
+#include "nt_blitter.h"
+#include "nt_unicode.h"
+#include "nt_socket.h"
+#include "nt_mount.h"
+#include "nt_istat.h"
+#include "nt_stat.h"
+#include "nt_statfs.h"
+#include "nt_daemon.h"
+#include "nt_vfd.h"
+#include "nt_tty.h"
+#include "nt_vmount.h"
+#include "nt_hash.h"
+#include "nt_debug.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef struct _ntapi_vtbl {
+ /* imported symbols: head */
+ /* nt_object.h */
+ ntapi_zw_query_object * zw_query_object;
+ ntapi_zw_set_information_object * zw_set_information_object;
+ ntapi_zw_duplicate_object * zw_duplicate_object;
+ ntapi_zw_make_temporary_object * zw_make_temporary_object;
+ ntapi_zw_close * zw_close;
+ ntapi_zw_query_security_object * zw_query_security_object;
+ ntapi_zw_set_security_object * zw_set_security_object;
+ ntapi_zw_create_directory_object * zw_create_directory_object;
+ ntapi_zw_open_directory_object * zw_open_directory_object;
+ ntapi_zw_query_directory_object * zw_query_directory_object;
+ ntapi_zw_create_symbolic_link_object * zw_create_symbolic_link_object;
+ ntapi_zw_open_symbolic_link_object * zw_open_symbolic_link_object;
+ ntapi_zw_query_symbolic_link_object * zw_query_symbolic_link_object;
+
+ /* nt_sysinfo.h */
+ ntapi_zw_query_system_information * zw_query_system_information;
+ ntapi_zw_set_system_information * zw_set_system_information;
+ ntapi_zw_query_system_environment_value * zw_query_system_environment_value;
+ ntapi_zw_set_system_environment_value * zw_set_system_environment_value;
+ ntapi_zw_shutdown_system * zw_shutdown_system;
+ ntapi_zw_system_debug_control * zw_system_debug_control;
+
+ /* nt_memory.h */
+ ntapi_zw_allocate_virtual_memory * zw_allocate_virtual_memory;
+ ntapi_zw_free_virtual_memory * zw_free_virtual_memory;
+ ntapi_zw_query_virtual_memory * zw_query_virtual_memory;
+ ntapi_zw_protect_virtual_memory * zw_protect_virtual_memory;
+ ntapi_zw_read_virtual_memory * zw_read_virtual_memory;
+ ntapi_zw_write_virtual_memory * zw_write_virtual_memory;
+ ntapi_zw_lock_virtual_memory * zw_lock_virtual_memory;
+ ntapi_zw_unlock_virtual_memory * zw_unlock_virtual_memory;
+ ntapi_zw_flush_virtual_memory * zw_flush_virtual_memory;
+ ntapi_zw_allocate_user_physical_pages * zw_allocate_user_physical_pages;
+ ntapi_zw_free_user_physical_pages * zw_free_user_physical_pages;
+ ntapi_zw_map_user_physical_pages * zw_map_user_physical_pages;
+ ntapi_zw_get_write_watch * zw_get_write_watch;
+ ntapi_zw_reset_write_watch * zw_reset_write_watch;
+
+ /* nt_section.h */
+ ntapi_zw_create_section * zw_create_section;
+ ntapi_zw_open_section * zw_open_section;
+ ntapi_zw_query_section * zw_query_section;
+ ntapi_zw_extend_section * zw_extend_section;
+ ntapi_zw_map_view_of_section * zw_map_view_of_section;
+ ntapi_zw_unmap_view_of_section * zw_unmap_view_of_section;
+ ntapi_zw_are_mapped_files_the_same * zw_are_mapped_files_the_same;
+
+ /* nt_thread.h */
+ ntapi_zw_create_thread * zw_create_thread;
+ ntapi_zw_open_thread * zw_open_thread;
+ ntapi_zw_terminate_thread * zw_terminate_thread;
+ ntapi_zw_query_information_thread * zw_query_information_thread;
+ ntapi_zw_set_information_thread * zw_set_information_thread;
+ ntapi_zw_suspend_thread * zw_suspend_thread;
+ ntapi_zw_resume_thread * zw_resume_thread;
+ ntapi_zw_get_context_thread * zw_get_context_thread;
+ ntapi_zw_set_context_thread * zw_set_context_thread;
+ ntapi_zw_queue_apc_thread * zw_queue_apc_thread;
+ ntapi_zw_test_alert * zw_test_alert;
+ ntapi_zw_alert_thread * zw_alert_thread;
+ ntapi_zw_alert_resume_thread * zw_alert_resume_thread;
+ ntapi_zw_register_thread_terminate_port * zw_register_thread_terminate_port;
+ ntapi_zw_impersonate_thread * zw_impersonate_thread;
+ ntapi_zw_impersonate_anonymous_token * zw_impersonate_anonymous_token;
+
+ /* nt_process.h */
+ ntapi_zw_create_process * zw_create_process;
+ ntapi_zw_create_user_process * zw_create_user_process;
+ ntapi_zw_open_process * zw_open_process;
+ ntapi_zw_terminate_process * zw_terminate_process;
+ ntapi_zw_query_information_process * zw_query_information_process;
+ ntapi_zw_set_information_process * zw_set_information_process;
+ ntapi_zw_flush_instruction_cache * zw_flush_instruction_cache;
+ ntapi_rtl_create_process_parameters * rtl_create_process_parameters;
+ ntapi_rtl_destroy_process_parameters * rtl_destroy_process_parameters;
+ ntapi_rtl_normalize_process_params * rtl_normalize_process_params;
+ ntapi_rtl_create_query_debug_buffer * rtl_create_query_debug_buffer;
+ ntapi_rtl_destroy_query_debug_buffer * rtl_destroy_query_debug_buffer;
+ ntapi_rtl_query_process_debug_information * rtl_query_process_debug_information;
+
+ /* nt_job.h */
+ ntapi_zw_create_job_object * zw_create_job_object;
+ ntapi_zw_open_job_object * zw_open_job_object;
+ ntapi_zw_terminate_job_object * zw_terminate_job_object;
+ ntapi_zw_assign_process_to_job_object * zw_assign_process_to_job_object;
+ ntapi_zw_query_information_job_object * zw_query_information_job_object;
+ ntapi_zw_set_information_job_object * zw_set_information_job_object;
+
+ /* nt_token.h */
+ ntapi_zw_create_token * zw_create_token;
+ ntapi_zw_open_process_token * zw_open_process_token;
+ ntapi_zw_open_thread_token * zw_open_thread_token;
+ ntapi_zw_duplicate_token * zw_duplicate_token;
+ ntapi_zw_filter_token * zw_filter_token;
+ ntapi_zw_adjust_privileges_token * zw_adjust_privileges_token;
+ ntapi_zw_adjust_groups_token * zw_adjust_groups_token;
+ ntapi_zw_query_information_token * zw_query_information_token;
+ ntapi_zw_set_information_token * zw_set_information_token;
+
+ /* nt_sync.h */
+ ntapi_zw_wait_for_single_object * zw_wait_for_single_object;
+ ntapi_zw_signal_and_wait_for_single_object * zw_signal_and_wait_for_single_object;
+ ntapi_zw_wait_for_multiple_objects * zw_wait_for_multiple_objects;
+ ntapi_zw_create_timer * zw_create_timer;
+ ntapi_zw_open_timer * zw_open_timer;
+ ntapi_zw_cancel_timer * zw_cancel_timer;
+ ntapi_zw_set_timer * zw_set_timer;
+ ntapi_zw_query_timer * zw_query_timer;
+ ntapi_zw_create_event * zw_create_event;
+ ntapi_zw_open_event * zw_open_event;
+ ntapi_zw_set_event * zw_set_event;
+ ntapi_zw_pulse_event * zw_pulse_event;
+ ntapi_zw_reset_event * zw_reset_event;
+ ntapi_zw_clear_event * zw_clear_event;
+ ntapi_zw_query_event * zw_query_event;
+ ntapi_zw_create_semaphore * zw_create_semaphore;
+ ntapi_zw_open_semaphore * zw_open_semaphore;
+ ntapi_zw_release_semaphore * zw_release_semaphore;
+ ntapi_zw_query_semaphore * zw_query_semaphore;
+ ntapi_zw_create_mutant * zw_create_mutant;
+ ntapi_zw_open_mutant * zw_open_mutant;
+ ntapi_zw_release_mutant * zw_release_mutant;
+ ntapi_zw_query_mutant * zw_query_mutant;
+ ntapi_zw_create_io_completion * zw_create_io_completion;
+ ntapi_zw_open_io_completion * zw_open_io_completion;
+ ntapi_zw_set_io_completion * zw_set_io_completion;
+ ntapi_zw_remove_io_completion * zw_remove_io_completion;
+ ntapi_zw_query_io_completion * zw_query_io_completion;
+ ntapi_zw_create_event_pair * zw_create_event_pair;
+ ntapi_zw_open_event_pair * zw_open_event_pair;
+ ntapi_zw_wait_low_event_pair * zw_wait_low_event_pair;
+ ntapi_zw_set_low_event_pair * zw_set_low_event_pair;
+ ntapi_zw_wait_high_event_pair * zw_wait_high_event_pair;
+ ntapi_zw_set_high_event_pair * zw_set_high_event_pair;
+ ntapi_zw_set_low_wait_high_event_pair * zw_set_low_wait_high_event_pair;
+ ntapi_zw_set_high_wait_low_event_pair * zw_set_high_wait_low_event_pair;
+
+ /* nt_time.h */
+ ntapi_zw_query_system_time * zw_query_system_time;
+ ntapi_zw_set_system_time * zw_set_system_time;
+ ntapi_zw_query_performance_counter * zw_query_performance_counter;
+ ntapi_zw_set_timer_resolution * zw_set_timer_resolution;
+ ntapi_zw_query_timer_resolution * zw_query_timer_resolution;
+ ntapi_zw_delay_execution * zw_delay_execution;
+ ntapi_zw_yield_execution * zw_yield_execution;
+
+ /* nt_profiling.h */
+ ntapi_zw_create_profile * zw_create_profile;
+ ntapi_zw_set_interval_profile * zw_set_interval_profile;
+ ntapi_zw_query_interval_profile * zw_query_interval_profile;
+ ntapi_zw_start_profile * zw_start_profile;
+ ntapi_zw_stop_profile * zw_stop_profile;
+
+ /* nt_port.h */
+ ntapi_zw_create_port * zw_create_port;
+ ntapi_zw_create_waitable_port * zw_create_waitable_port;
+ ntapi_zw_connect_port * zw_connect_port;
+ ntapi_zw_secure_connect_port * zw_secure_connect_port;
+ ntapi_zw_listen_port * zw_listen_port;
+ ntapi_zw_accept_connect_port * zw_accept_connect_port;
+ ntapi_zw_complete_connect_port * zw_complete_connect_port;
+ ntapi_zw_request_port * zw_request_port;
+ ntapi_zw_request_wait_reply_port * zw_request_wait_reply_port;
+ ntapi_zw_reply_port * zw_reply_port;
+ ntapi_zw_reply_wait_reply_port * zw_reply_wait_reply_port;
+ ntapi_zw_reply_wait_receive_port * zw_reply_wait_receive_port;
+ ntapi_zw_reply_wait_receive_port_ex * zw_reply_wait_receive_port_ex;
+ ntapi_zw_read_request_data * zw_read_request_data;
+ ntapi_zw_write_request_data * zw_write_request_data;
+ ntapi_zw_query_information_port * zw_query_information_port;
+ ntapi_zw_impersonate_client_of_port * zw_impersonate_client_of_port;
+ ntapi_csr_client_call_server * csr_client_call_server;
+ ntapi_csr_port_handle * csr_port_handle;
+
+ /* nt_device.h */
+ ntapi_zw_load_driver * zw_load_driver;
+ ntapi_zw_unload_driver * zw_unload_driver;
+
+ /* nt_file.h */
+ ntapi_zw_create_file * zw_create_file;
+ ntapi_zw_open_file * zw_open_file;
+ ntapi_zw_delete_file * zw_delete_file;
+ ntapi_zw_flush_buffers_file * zw_flush_buffers_file;
+ ntapi_zw_cancel_io_file * zw_cancel_io_file;
+ ntapi_zw_cancel_io_file_ex * zw_cancel_io_file_ex;
+ ntapi_zw_read_file * zw_read_file;
+ ntapi_zw_write_file * zw_write_file;
+ ntapi_zw_read_file_scatter * zw_read_file_scatter;
+ ntapi_zw_write_file_gather * zw_write_file_gather;
+ ntapi_zw_lock_file * zw_lock_file;
+ ntapi_zw_unlock_file * zw_unlock_file;
+ ntapi_zw_device_io_control_file * zw_device_io_control_file;
+ ntapi_zw_fs_control_file * zw_fs_control_file;
+ ntapi_zw_notify_change_directory_file * zw_notify_change_directory_file;
+ ntapi_zw_query_ea_file * zw_query_ea_file;
+ ntapi_zw_set_ea_file * zw_set_ea_file;
+ ntapi_zw_create_named_pipe_file * zw_create_named_pipe_file;
+ ntapi_zw_create_mailslot_file * zw_create_mailslot_file;
+ ntapi_zw_query_volume_information_file * zw_query_volume_information_file;
+ ntapi_zw_set_volume_information_file * zw_set_volume_information_file;
+ ntapi_zw_query_quota_information_file * zw_query_quota_information_file;
+ ntapi_zw_set_quota_information_file * zw_set_quota_information_file;
+ ntapi_zw_query_attributes_file * zw_query_attributes_file;
+ ntapi_zw_query_full_attributes_file * zw_query_full_attributes_file;
+ ntapi_zw_query_directory_file * zw_query_directory_file;
+ ntapi_zw_query_information_file * zw_query_information_file;
+ ntapi_zw_set_information_file * zw_set_information_file;
+
+ /* nt_resistry.h */
+ ntapi_zw_create_key * zw_create_key;
+ ntapi_zw_open_key * zw_open_key;
+ ntapi_zw_delete_key * zw_delete_key;
+ ntapi_zw_flush_key * zw_flush_key;
+ ntapi_zw_save_key * zw_save_key;
+ ntapi_zw_save_merged_keys * zw_save_merged_keys;
+ ntapi_zw_restore_key * zw_restore_key;
+ ntapi_zw_load_key * zw_load_key;
+ ntapi_zw_load_key2 * zw_load_key2;
+ ntapi_zw_unload_key * zw_unload_key;
+ ntapi_zw_query_open_sub_keys * zw_query_open_sub_keys;
+ ntapi_zw_replace_key * zw_replace_key;
+ ntapi_zw_set_information_key * zw_set_information_key;
+ ntapi_zw_query_key * zw_query_key;
+ ntapi_zw_enumerate_key * zw_enumerate_key;
+ ntapi_zw_notify_change_key * zw_notify_change_key;
+ ntapi_zw_notify_change_multiple_keys * zw_notify_change_multiple_keys;
+ ntapi_zw_delete_value_key * zw_delete_value_key;
+ ntapi_zw_set_value_key * zw_set_value_key;
+ ntapi_zw_query_value_key * zw_query_value_key;
+ ntapi_zw_enumerate_value_key * zw_enumerate_value_key;
+ ntapi_zw_query_multiple_value_key * zw_query_multiple_value_key;
+ ntapi_zw_initialize_registry * zw_initialize_registry;
+
+ /* nt_security.h */
+ ntapi_zw_privilege_check * zw_privilege_check;
+ ntapi_zw_privilege_object_audit_alarm * zw_privilege_object_audit_alarm;
+ ntapi_zw_privileged_service_audit_alarm * zw_privileged_service_audit_alarm;
+ ntapi_zw_access_check * zw_access_check;
+ ntapi_zw_access_check_and_audit_alarm * zw_access_check_and_audit_alarm;
+ ntapi_zw_access_check_by_type * zw_access_check_by_type;
+ ntapi_zw_access_check_by_type_result_list * zw_access_check_by_type_result_list;
+ ntapi_zw_open_object_audit_alarm * zw_open_object_audit_alarm;
+ ntapi_zw_close_object_audit_alarm * zw_close_object_audit_alarm;
+ ntapi_zw_delete_object_audit_alarm * zw_delete_object_audit_alarm;
+
+ ntapi_zw_access_check_by_type_and_audit_alarm * zw_access_check_by_type_and_audit_alarm;
+
+ ntapi_zw_access_check_by_type_result_list_and_audit_alarm * zw_access_check_by_type_result_list_and_audit_alarm;
+ ntapi_zw_access_check_by_type_result_list_and_audit_alarm_by_handle * zw_access_check_by_type_result_list_and_audit_alarm_by_handle;
+
+ /* nt_pnp.h */
+ ntapi_zw_is_system_resume_automatic * zw_is_system_resume_automatic;
+ ntapi_zw_set_thread_execution_state * zw_set_thread_execution_state;
+ ntapi_zw_get_device_power_state * zw_get_device_power_state;
+ ntapi_zw_set_system_power_state * zw_set_system_power_state;
+ ntapi_zw_initiate_power_action * zw_initiate_power_action;
+ ntapi_zw_power_information * zw_power_information;
+ ntapi_zw_plug_play_control * zw_plug_play_control;
+ ntapi_zw_get_plug_play_event * zw_get_plug_play_event;
+
+ /* nt_exception */
+ ntapi_zw_raise_exception * zw_raise_exception;
+ ntapi_zw_continue * zw_continue;
+
+ /* nt_locale */
+ ntapi_zw_query_default_locale * zw_query_default_locale;
+ ntapi_zw_set_default_locale * zw_set_default_locale;
+ ntapi_zw_query_default_ui_language * zw_query_default_ui_language;
+ ntapi_zw_set_default_ui_language * zw_set_default_ui_language;
+ ntapi_zw_query_install_ui_language * zw_query_install_ui_language;
+
+ /* nt_uuid.h */
+ ntapi_zw_allocate_locally_unique_id * zw_allocate_locally_unique_id;
+ ntapi_zw_allocate_uuids * zw_allocate_uuids;
+ ntapi_zw_set_uuid_seed * zw_set_uuid_seed;
+
+ /* nt_atom.h */
+ ntapi_zw_add_atom * zw_add_atom;
+ ntapi_zw_find_atom * zw_find_atom;
+ ntapi_zw_delete_atom * zw_delete_atom;
+ ntapi_zw_query_information_atom * zw_query_information_atom;
+
+ /* nt_os.h */
+ ntapi_zw_flush_write_buffer * zw_flush_write_buffer;
+ ntapi_zw_raise_hard_error * zw_raise_hard_error;
+ ntapi_zw_set_default_hard_error_port * zw_set_default_hard_error_port;
+ ntapi_zw_display_string * zw_display_string;
+ ntapi_zw_create_paging_file * zw_create_paging_file;
+ ntapi_zw_set_ldt_entries * zw_set_ldt_entries;
+ ntapi_zw_vdm_control * zw_vdm_control;
+
+ /* nt_ldr.h */
+ ntapi_ldr_load_dll * ldr_load_dll;
+ ntapi_ldr_unload_dll * ldr_unload_dll;
+
+ /* nt_string.h */
+ ntapi_memset * memset;
+ ntapi_sprintf * sprintf;
+ ntapi_strlen * strlen;
+ /* imported symbols: tail */
+
+ /* alternate implementation */
+ /* nt_string.h */
+ ntapi_wcslen * wcslen;
+ ntapi_rtl_init_unicode_string * rtl_init_unicode_string;
+
+ /* extension functions */
+ /* nt_object.h */
+ ntapi_tt_create_keyed_object_directory * tt_create_keyed_object_directory;
+ ntapi_tt_open_keyed_object_directory * tt_open_keyed_object_directory;
+ ntapi_tt_create_keyed_object_directory_entry * tt_create_keyed_object_directory_entry;
+
+ /* nt_crc32.h */
+ ntapi_tt_buffer_crc32 * tt_buffer_crc32;
+ ntapi_tt_mbstr_crc32 * tt_mbstr_crc32;
+ ntapi_tt_crc32_table * tt_crc32_table;
+
+ /* nt_file.h */
+ ntapi_tt_get_file_handle_type * tt_get_file_handle_type;
+ ntapi_tt_open_logical_parent_directory * tt_open_logical_parent_directory;
+ ntapi_tt_open_physical_parent_directory * tt_open_physical_parent_directory;
+
+ /* nt_ipc.h */
+ ntapi_ipc_create_pipe * ipc_create_pipe;
+
+ /* nt_ldr.h */
+ ntapi_ldr_load_system_dll * ldr_load_system_dll;
+ ntapi_ldr_create_state_snapshot * ldr_create_state_snapshot;
+ ntapi_ldr_revert_state_to_snapshot * ldr_revert_state_to_snapshot;
+
+ /* nt_string.h */
+ ntapi_tt_string_null_offset_multibyte * tt_string_null_offset_multibyte;
+ ntapi_tt_string_null_offset_short * tt_string_null_offset_short;
+ ntapi_tt_string_null_offset_dword * tt_string_null_offset_dword;
+ ntapi_tt_string_null_offset_qword * tt_string_null_offset_qword;
+ ntapi_tt_string_null_offset_ptrsize * tt_string_null_offset_ptrsize;
+ ntapi_tt_aligned_block_memset * tt_aligned_block_memset;
+ ntapi_tt_aligned_block_memcpy * tt_aligned_block_memcpy;
+ ntapi_tt_aligned_memcpy_utf16 * tt_aligned_memcpy_utf16;
+ ntapi_tt_memcpy_utf16 * tt_memcpy_utf16;
+ ntapi_tt_generic_memset * tt_generic_memset;
+ ntapi_tt_generic_memcpy * tt_generic_memcpy;
+ ntapi_tt_uint16_to_hex_utf16 * tt_uint16_to_hex_utf16;
+ ntapi_tt_uint32_to_hex_utf16 * tt_uint32_to_hex_utf16;
+ ntapi_tt_uint64_to_hex_utf16 * tt_uint64_to_hex_utf16;
+ ntapi_tt_uintptr_to_hex_utf16 * tt_uintptr_to_hex_utf16;
+ ntapi_tt_hex_utf16_to_uint16 * tt_hex_utf16_to_uint16;
+ ntapi_tt_hex_utf16_to_uint32 * tt_hex_utf16_to_uint32;
+ ntapi_tt_hex_utf16_to_uint64 * tt_hex_utf16_to_uint64;
+ ntapi_tt_hex_utf16_to_uintptr * tt_hex_utf16_to_uintptr;
+ ntapi_tt_uint16_to_hex_utf8 * tt_uint16_to_hex_utf8;
+ ntapi_tt_uint32_to_hex_utf8 * tt_uint32_to_hex_utf8;
+ ntapi_tt_uint64_to_hex_utf8 * tt_uint64_to_hex_utf8;
+ ntapi_tt_uintptr_to_hex_utf8 * tt_uintptr_to_hex_utf8;
+ ntapi_tt_init_unicode_string_from_utf16* tt_init_unicode_string_from_utf16;
+
+ /* nt_guid.h */
+ ntapi_tt_guid_copy * tt_guid_copy;
+ ntapi_tt_guid_compare * tt_guid_compare;
+ ntapi_tt_guid_to_utf16_string * tt_guid_to_utf16_string;
+ ntapi_tt_utf16_string_to_guid * tt_utf16_string_to_guid;
+
+ /* nt_sysinfo.h */
+ ntapi_tt_get_system_directory_native_path * tt_get_system_directory_native_path;
+ ntapi_tt_get_system_directory_dos_path * tt_get_system_directory_dos_path;
+ ntapi_tt_get_system_directory_handle * tt_get_system_directory_handle;
+ ntapi_tt_get_system_info_snapshot * tt_get_system_info_snapshot;
+
+ /* nt_thread.h */
+ ntapi_tt_create_thread * tt_create_thread;
+ ntapi_tt_create_local_thread * tt_create_local_thread;
+ ntapi_tt_create_remote_thread * tt_create_remote_thread;
+
+ /* nt_process.h */
+ ntapi_tt_fork * tt_fork;
+ ntapi_tt_create_remote_process_params * tt_create_remote_process_params;
+ ntapi_tt_create_native_process * tt_create_native_process;
+ ntapi_tt_get_runtime_data * tt_get_runtime_data;
+ ntapi_tt_init_runtime_data * tt_init_runtime_data;
+ ntapi_tt_update_runtime_data * tt_update_runtime_data;
+ ntapi_tt_exec_map_image_as_data * tt_exec_map_image_as_data;
+ ntapi_tt_exec_unmap_image * tt_exec_unmap_image;
+
+ /* nt_section.h */
+ ntapi_tt_get_section_name * tt_get_section_name;
+
+ /* nt_sync.h */
+ ntapi_tt_create_inheritable_event * tt_create_inheritable_event;
+ ntapi_tt_create_private_event * tt_create_private_event;
+ ntapi_tt_sync_block_init * tt_sync_block_init;
+ ntapi_tt_sync_block_lock * tt_sync_block_lock;
+ ntapi_tt_sync_block_server_lock * tt_sync_block_server_lock;
+ ntapi_tt_sync_block_unlock * tt_sync_block_unlock;
+ ntapi_tt_sync_block_invalidate * tt_sync_block_invalidate;
+ ntapi_tt_wait_for_dummy_event * tt_wait_for_dummy_event;
+
+ /* nt_port.h */
+ ntapi_tt_port_guid_from_type * tt_port_guid_from_type;
+ ntapi_tt_port_type_from_guid * tt_port_type_from_guid;
+ ntapi_tt_port_generate_keys * tt_port_generate_keys;
+ ntapi_tt_port_format_keys * tt_port_format_keys;
+ ntapi_tt_port_name_from_attributes * tt_port_name_from_attributes;
+
+ /* nt_argv.h */
+ ntapi_tt_get_cmd_line_utf16 * tt_get_cmd_line_utf16;
+ ntapi_tt_get_peb_env_block_utf16 * tt_get_peb_env_block_utf16;
+ ntapi_tt_parse_cmd_line_args_utf16 * tt_parse_cmd_line_args_utf16;
+ ntapi_tt_get_argv_envp_utf8 * tt_get_argv_envp_utf8;
+ ntapi_tt_get_argv_envp_utf16 * tt_get_argv_envp_utf16;
+ ntapi_tt_get_env_var_meta_utf16 * tt_get_env_var_meta_utf16;
+ ntapi_tt_get_short_option_meta_utf16 * tt_get_short_option_meta_utf16;
+ ntapi_tt_get_long_option_meta_utf16 * tt_get_long_option_meta_utf16;
+ ntapi_tt_array_copy_utf8 * tt_array_copy_utf8;
+ ntapi_tt_array_copy_utf16 * tt_array_copy_utf16;
+ ntapi_tt_array_convert_utf8_to_utf16 * tt_array_convert_utf8_to_utf16;
+ ntapi_tt_array_convert_utf16_to_utf8 * tt_array_convert_utf16_to_utf8;
+
+ /* nt_blitter.h */
+ ntapi_blt_alloc * blt_alloc;
+ ntapi_blt_free * blt_free;
+ ntapi_blt_acquire * blt_acquire;
+ ntapi_blt_obtain * blt_obtain;
+ ntapi_blt_possess * blt_possess;
+ ntapi_blt_release * blt_release;
+ ntapi_blt_get * blt_get;
+ ntapi_blt_set * blt_set;
+
+ /* nt_unicode.h */
+ ntapi_uc_validate_unicode_stream_utf8 * uc_validate_unicode_stream_utf8;
+ ntapi_uc_validate_unicode_stream_utf16 * uc_validate_unicode_stream_utf16;
+ ntapi_uc_get_code_point_byte_count_utf8 * uc_get_code_point_byte_count_utf8;
+ ntapi_uc_get_code_point_byte_count_utf16 * uc_get_code_point_byte_count_utf16;
+ ntapi_uc_convert_unicode_stream_utf8_to_utf16 * uc_convert_unicode_stream_utf8_to_utf16;
+ ntapi_uc_convert_unicode_stream_utf8_to_utf32 * uc_convert_unicode_stream_utf8_to_utf32;
+ ntapi_uc_convert_unicode_stream_utf16_to_utf8 * uc_convert_unicode_stream_utf16_to_utf8;
+ ntapi_uc_convert_unicode_stream_utf16_to_utf32 *uc_convert_unicode_stream_utf16_to_utf32;
+
+ /* nt_daemon.h */
+ ntapi_dsr_init * dsr_init;
+ ntapi_dsr_start * dsr_start;
+ ntapi_dsr_create_port * dsr_create_port;
+ ntapi_dsr_connect_internal_client * dsr_connect_internal_client;
+ ntapi_dsr_internal_client_connect * dsr_internal_client_connect;
+
+ /* nt_vfd.h */
+ ntapi_vfd_dev_name_init * vfd_dev_name_init;
+
+ /* nt_tty.h */
+ ntapi_tty_create_session * tty_create_session;
+ ntapi_tty_join_session * tty_join_session;
+ ntapi_tty_connect * tty_connect;
+ ntapi_tty_client_session_query * tty_client_session_query;
+ ntapi_tty_client_session_set * tty_client_session_set;
+ ntapi_tty_client_process_register * tty_client_process_register;
+ ntapi_tty_query_information_server * tty_query_information_server;
+ ntapi_tty_request_peer * tty_request_peer;
+ ntapi_tty_vms_query * tty_vms_query;
+ ntapi_tty_vms_request * tty_vms_request;
+ ntapi_pty_open * pty_open;
+ ntapi_pty_reopen * pty_reopen;
+ ntapi_pty_close * pty_close;
+ ntapi_pty_read * pty_read;
+ ntapi_pty_write * pty_write;
+ ntapi_pty_fcntl * pty_fcntl;
+ ntapi_pty_ioctl * pty_ioctl;
+ ntapi_pty_query * pty_query;
+ ntapi_pty_set * pty_set;
+ ntapi_pty_cancel * pty_cancel;
+
+ /* nt_socket.h */
+ ntapi_sc_socket * sc_socket;
+ ntapi_sc_bind * sc_bind;
+ ntapi_sc_listen * sc_listen;
+ ntapi_sc_accept * sc_accept;
+ ntapi_sc_connect * sc_connect;
+ ntapi_sc_send * sc_send;
+ ntapi_sc_recv * sc_recv;
+ ntapi_sc_shutdown * sc_shutdown;
+ ntapi_sc_getsockname * sc_getsockname;
+ ntapi_sc_server_accept_connection * sc_server_accept_connection;
+ ntapi_sc_server_duplicate_socket * sc_server_duplicate_socket;
+ ntapi_sc_wait * sc_wait;
+
+ /* nt_mount.h */
+ ntapi_tt_get_dos_drive_device_handle * tt_get_dos_drive_device_handle;
+ ntapi_tt_get_dos_drive_root_handle * tt_get_dos_drive_root_handle;
+ ntapi_tt_get_dos_drive_device_name * tt_get_dos_drive_device_name;
+ ntapi_tt_get_dos_drive_mount_points * tt_get_dos_drive_mount_points;
+ ntapi_tt_dev_mount_points_to_statfs * tt_dev_mount_points_to_statfs;
+ ntapi_tt_get_dos_drive_letter_from_device * tt_get_dos_drive_letter_from_device;
+
+ /* nt_istat.h */
+ ntapi_tt_istat * tt_istat;
+ ntapi_tt_validate_fs_handle * tt_validate_fs_handle;
+
+ /* nt_stat.h */
+ ntapi_tt_stat * tt_stat;
+
+ /* nt_statfs.h */
+ ntapi_tt_statfs * tt_statfs;
+
+ /* nt_vmount.h */
+ ntapi_vms_get_node_by_dev_name * vms_get_node_by_dev_name;
+ ntapi_vms_get_node_by_end_component * vms_get_node_by_end_component;
+ ntapi_vms_cache_alloc * vms_cache_alloc;
+ ntapi_vms_cache_free * vms_cache_free;
+ ntapi_vms_client_connect * vms_client_connect;
+ ntapi_vms_client_disconnect * vms_client_disconnect;
+ ntapi_vms_point_attach * vms_point_attach;
+ ntapi_vms_point_get_handles * vms_point_get_handles;
+ ntapi_vms_ref_count_inc * vms_ref_count_inc;
+ ntapi_vms_ref_count_dec * vms_ref_count_dec;
+ ntapi_vms_table_query * vms_table_query;
+
+ /* nt_debug.h */
+ ntapi_dbg_write * dbg_write;
+ ntapi_dbg_fn_call * dbg_fn_call;
+ ntapi_dbg_msg * dbg_msg;
+} ntapi_vtbl;
+
+
+__ntapi_api
+int32_t __fastcall ntapi_init(ntapi_vtbl ** pvtbl);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/ntapi.lzy b/ntapi.lzy
new file mode 100644
index 0000000..8ce26c8
--- /dev/null
+++ b/ntapi.lzy
@@ -0,0 +1,113 @@
+lz_project_rules()
+{
+ lz_rules="all install"
+}
+
+lz_project_definitions()
+{
+ ntapi_lib_name=libntapi
+ ntapi_so_name="$lz_build_dir/lib/$ntapi_lib_name$lz_dylib_ext"
+ ntapi_a_name="$lz_build_dir/lib/$ntapi_lib_name$lz_stlib_ext"
+ ntapi_so_def_name="$lz_build_dir/lib/$ntapi_lib_name$lz_libdef_ext"
+ ntapi_implib_name="$lz_build_dir/lib/$ntapi_lib_name$lz_implib_ext"
+
+ lz_cflags_common="-DMIDIPIX_FREESTANDING
+ -D__NT$lz_arch_bits \
+ -UWIN32 -U_WIN32 -U__WIN32 -U__WIN32__ \
+ -UWIN64 -U_WIN64 -U__WIN64 -U__WIN64__ \
+ -Werror=all -fno-builtin -ffreestanding"
+
+
+ # lz_cflags_extra="-Os -fno-stack-protector -fomit-frame-pointer -fno-unwind-tables -fno-asynchronous-unwind-tables"
+
+ ntapi_so_ldflags="-shared --image-base=0x800000 \
+ --entry "$lz_default_underscore"__ntapi_entry@12 \
+ --exclude-all-symbols \
+ --output-def $ntapi_so_def_name \
+ --out-implib $ntapi_implib_name \
+ --subsystem=windows"
+
+ lz_cflags_include_first="-I$lz_project_dir/src/internal -I$lz_project_dir/include"
+
+ if [ "$MIDIPIX_ROOT"x != x ]; then
+ lz_cflags_include_common="$lz_cflags_include_common -I$MIDIPIX_ROOT/include"
+ fi
+
+ ntapi_so_obj_list=ntapi.so.objs
+ ntapi_so_src_list=ntapi.so.src.lst
+
+ ntapi_a_obj_list=ntapi.a.objs
+ ntapi_a_src_list=ntapi.a.src.lst
+}
+
+ntapi_shared()
+{
+ lz_src_dirs="src"
+ lz_cflags_step="-DNTAPI_BUILD \
+ -DPE_SHARED \
+ -DDALIST_SHARED"
+
+ if ! [ "$lz_pecoff_winnt"x = yesx ]; then
+ lz_cflags_step="$lz_cflags_step -fpic"
+ fi
+
+ lz_compile "$ntapi_so_obj_list" "$ntapi_so_src_list" "$lz_dyobj_ext"
+ lz_link "$ntapi_so_obj_list" "$ntapi_so_src_list" "$ntapi_so_name" \
+ "$ntapi_so_ldflags" \
+ "$lz_ldflags_cmdline -lpemagine -ldalist"
+}
+
+
+ntapi_static()
+{
+ lz_src_dirs="src"
+
+ lz_compile "$ntapi_a_obj_list" "$ntapi_a_src_list" "$lz_stobj_ext"
+ lz_archive "$ntapi_a_obj_list" "$ntapi_a_src_list" "$ntapi_a_name"
+}
+
+
+ntapi_install_headers()
+{
+ lz_pushd $lz_project_dir
+
+ cp -r -t $lz_prefix/include include/$lz_project_name
+
+ lz_popd
+}
+
+
+ntapi_install_shared()
+{
+ lz_pushd $lz_build_dir/lib
+
+ cp -t $lz_prefix/lib $ntapi_lib_name$lz_dylib_ext
+ cp -t $lz_prefix/lib $ntapi_lib_name$lz_implib_ext
+
+ lz_popd
+}
+
+
+ntapi_install_static()
+{
+ lz_pushd $lz_build_dir/lib
+
+ cp -t $lz_prefix/lib $ntapi_lib_name$lz_stlib_ext
+
+ lz_popd
+}
+
+ntapi_all()
+{
+ lz_step ntapi_shared
+ lz_step ntapi_static
+}
+
+
+ntapi_install()
+{
+ lz_step ntapi_all
+ lz_step ntapi_install_shared
+ lz_step ntapi_install_static
+ lz_step ntapi_install_headers
+}
diff --git a/src/argv/ntapi_tt_argv_envp.c b/src/argv/ntapi_tt_argv_envp.c
new file mode 100644
index 0000000..bfa0cd2
--- /dev/null
+++ b/src/argv/ntapi_tt_argv_envp.c
@@ -0,0 +1,717 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <pemagine/pemagine.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+
+/**
+ * rules for parsing the process's command line arguments
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
+ *
+ * delimiters:
+ * -----------
+ * + white space (ascii 0x20)
+ * + horizontal tab (ascii 0x09)
+ *
+ * quoted strings, and special characters
+ * --------------------------------------
+ * + delimiter characters within a quoted string ("string with white space",
+ * or string" with white "space), stand for their literal respective
+ * characters.
+ *
+ * + a backslash followed by a double quote (\") stands for a literal
+ * double quote.
+ *
+ * + unless followed by a double quote, a backslash is just a (literal)
+ * backslash.
+ *
+ * + when followed by a double quotation mark, an even sequence of 2 or
+ * more backslashes (2n) should be interpreted as a sequence of n literal
+ * backslashes. The double quotation mark then designates the start
+ * or end of a double quoted string.
+ *
+ * + when followed by a double quotation mark, an odd sequence of 2 or
+ * more backslashes (2n+1) should be interpreted as a sequence of n
+ * literal backslashes, followed by a single literal double quote.
+ *
+ * + if found within a double quoted string, a sequence of two double
+ * quotation marks should be interpreted as a single literal double
+ * quote.
+ *
+ * + balanced nesting of syntactic double quotes is permitted.
+ *
+**/
+
+/* free-standing process runtime data */
+static nt_runtime_data __rtdata;
+
+int32_t __stdcall __ntapi_tt_parse_cmd_line_args_utf16(
+ __in wchar16_t * cmd_line,
+ __out int * arg_count,
+ __in wchar16_t * args_buffer,
+ __in size_t args_buffer_len,
+ __out size_t * args_bytes_written __optional,
+ __in wchar16_t ** argv_buffer,
+ __in size_t argv_buffer_len,
+ __in uint32_t arg_flags)
+{
+ /**
+ * parse the command line arguments pointed to by cmd_line,
+ * copy the parsed arguments to args_buffer,
+ * and return 0 upon success.
+ *
+ * cmd_line must be a valid pointer to a command line string,
+ * and args_buffer, argv_buffer, and arg_count should
+ * all be aligned; furthermore, args_buffer_len and
+ * and argv_buffer_len must be exact multiples of sizeof(size_t).
+ *
+ * In case of an error, report failure using the appropriate
+ * native status code.
+ **/
+
+ /**
+ * UTF-16: no need to fully determine the code point of the
+ * current character; all we need to do is validate the
+ * character or surrogate pair, and set the value of
+ * wch_next accordingly.
+ **/
+
+ #define HORIZONTAL_TAB 0x09
+ #define WHITE_SPACE 0x20
+ #define DOUBLE_QUOTE 0x22
+ #define SINGLE_QUOTE 0x27
+ #define BACKSLASH 0x5C
+
+ #define IS_DELIMITER(x) ((x == HORIZONTAL_TAB) || (x == WHITE_SPACE))
+
+ #define TEST_ARGS_BUFFER(nbytes) \
+ if ((uintptr_t)arg + nbytes \
+ > (uintptr_t)args_buffer + args_buffer_len) { \
+ return NT_STATUS_BUFFER_TOO_SMALL; \
+ }
+
+ #define ADD_N_BACKSLASHES \
+ TEST_ARGS_BUFFER(backslash_count * sizeof(wchar16_t)); \
+ for (islash = 0; \
+ islash < backslash_count; \
+ islash++) { \
+ *arg = BACKSLASH; \
+ arg++; \
+ } \
+ backslash_count = 0;
+
+ #define ADD_SINGLE_WCHAR16_t(x) \
+ TEST_ARGS_BUFFER(sizeof(wchar16_t)); \
+ *arg = x; \
+ arg++;
+
+ wchar16_t * arg; /* null-terminated, copied to buffer */
+ wchar16_t ** parg; /* next pointer in the argv array */
+ wchar16_t * wch; /* character being processed */
+ wchar16_t * wch_next;
+ unsigned int backslash_count;
+ unsigned int islash;
+ unsigned char quoted_state;
+
+ /* check parameters for validity and alignment */
+ if ((!(uintptr_t)cmd_line) || (*cmd_line == 0))
+ /* we require at least one argument */
+ return NT_STATUS_INVALID_PARAMETER_1;
+
+ else if (__NT_IS_MISALIGNED_BUFFER(args_buffer))
+ return NT_STATUS_INVALID_PARAMETER_2;
+
+ else if (__NT_IS_MISALIGNED_LENGTH(args_buffer_len))
+ return NT_STATUS_INVALID_PARAMETER_3;
+
+ else if (__NT_IS_MISALIGNED_BUFFER(argv_buffer))
+ return NT_STATUS_INVALID_PARAMETER_5;
+
+ else if (__NT_IS_MISALIGNED_LENGTH(argv_buffer_len))
+ return NT_STATUS_INVALID_PARAMETER_6;
+
+ else if (__NT_IS_MISALIGNED_BUFFER(arg_count))
+ return NT_STATUS_INVALID_PARAMETER_7;
+
+ /* zero-out the aligned buffers */
+ __ntapi->tt_aligned_block_memset(args_buffer,0,args_buffer_len);
+ __ntapi->tt_aligned_block_memset(argv_buffer,0,argv_buffer_len);
+
+ /* initialize */
+ wch = cmd_line;
+ arg = args_buffer;
+ parg = argv_buffer;
+ *parg = arg;
+ *arg_count = 0;
+ quoted_state = 0;
+ backslash_count = 0;
+
+ /* arg points to the first character of a command line argument */
+ /* parg points to the next pointer in argv_buffer */
+ while (*wch) {
+ if (!(quoted_state) && (IS_DELIMITER(*wch))) {
+ /* pending backslashes? */
+ if (backslash_count)
+ ADD_N_BACKSLASHES;
+
+ /* reached a delimiter outside of a quoted string */
+ /* argument: alignment and null-termination */
+ arg = (wchar16_t *)((((uintptr_t)arg + sizeof(size_t))
+ | (sizeof(size_t) - 1))
+ ^ (sizeof(size_t) - 1));
+
+ /* skip this and remaining delimiters */
+ wch_next = wch + 1;
+ while ((*wch_next) && (IS_DELIMITER(*wch_next)))
+ wch_next++;
+
+ /* keep going? */
+ if (*wch_next == 0) {
+ /* no more characters to process */
+ /* nothing to do */
+ } else if ((uintptr_t)parg >= \
+ (uintptr_t)argv_buffer \
+ + argv_buffer_len) {
+ /* argv_buffer is too small */
+ return NT_STATUS_BUFFER_TOO_SMALL;
+ } else if ((uintptr_t)arg >= \
+ (uintptr_t)args_buffer \
+ + args_buffer_len) {
+ /* args_buffer is too small */
+ return NT_STATUS_BUFFER_TOO_SMALL;
+ } else {
+ /* advance parg, set last member */
+ parg++;
+ *parg = arg;
+ }
+ } else {
+ /* the current character is not a delimiter... */
+ /* determine wch_next */
+ if (((*wch >= 0x0000) && (*wch < 0xD800)) \
+ || ((*wch >= 0xE000) && (*wch < 0x10000))) {
+ /* in the BMP, single 16-bit representation */
+ wch_next = wch + 1;
+ } else if ((*wch >= 0xD800) && (*wch < 0xDC00)) {
+ /* validate surrogate pair */
+ wch_next = wch + 1;
+
+ if ((*wch_next >= 0xDC00) && (*wch_next < 0xE000))
+ /* this is a valid surrogate pair */
+ wch_next++;
+ else
+ return NT_STATUS_ILLEGAL_CHARACTER;
+ } else
+ return NT_STATUS_ILLEGAL_CHARACTER;
+
+ /* we now know the position of this and the next character */
+ /* continue with special cases */
+
+ if (quoted_state && (*wch == DOUBLE_QUOTE) \
+ && (*wch_next == DOUBLE_QUOTE)) {
+ /**
+ * two consecutive double quotation marks
+ * within a quoted string:
+ * add a single quotation mark to the argument
+ **/
+ ADD_SINGLE_WCHAR16_t(DOUBLE_QUOTE);
+ wch_next++;
+ } else if (((backslash_count % 2) == 0) \
+ && (*wch == BACKSLASH) \
+ && (*wch_next == DOUBLE_QUOTE)) {
+ /* 2n+1 backslashes followed by a double quote */
+ backslash_count /= 2;
+ /* add n backslashes */
+ ADD_N_BACKSLASHES;
+ /* add a literal double quotation mark */
+ ADD_SINGLE_WCHAR16_t(DOUBLE_QUOTE);
+ /* get ready for next character */
+ wch_next++;
+ } else if (backslash_count && (*wch == DOUBLE_QUOTE)) {
+ /* 2n backslashes followed by a double quote */
+ backslash_count /= 2;
+ /* add n backslashes */
+ ADD_N_BACKSLASHES;
+ /* turn quoted_state on/off */
+ quoted_state = !quoted_state;
+ } else if ((*wch == BACKSLASH) \
+ && (*wch_next == BACKSLASH)) {
+ /* this is a sequence of two backslashes */
+ backslash_count += 2;
+ wch_next++;
+ } else {
+ /* copy pending backslashes as needed */
+ if (backslash_count)
+ ADD_N_BACKSLASHES;
+
+ if (*wch == DOUBLE_QUOTE) {
+ /* turn quoted_state on/off */
+ quoted_state = !quoted_state;
+ } else {
+ /* copy either two or four bytes */
+ ADD_SINGLE_WCHAR16_t(*wch);
+ wch++;
+
+ /* surrogate pair? */
+ if (wch < wch_next) {
+ ADD_SINGLE_WCHAR16_t(*wch);
+ }
+ }
+ }
+ }
+
+ /* proceed to the next character (or null termination) */
+ wch = wch_next;
+ }
+
+ /* pending backslashes? */
+ if (backslash_count)
+ ADD_N_BACKSLASHES;
+
+ /* null termination */
+ ADD_SINGLE_WCHAR16_t(0);
+
+ /* how many arguments did you say? */
+ *arg_count = (int)(((uintptr_t)parg - (uintptr_t)argv_buffer)
+ / sizeof(size_t) + 1);
+
+ /* output bytes written */
+ if (args_bytes_written)
+ *args_bytes_written = (uintptr_t)arg - (uintptr_t)args_buffer;
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+int32_t __stdcall __ntapi_tt_get_argv_envp_utf16(
+ __out int * argc,
+ __out wchar16_t *** wargv,
+ __out wchar16_t *** wenvp,
+ __in uint32_t flags,
+ __in void * ext_params __optional,
+ __out void * reserved __optional)
+{
+ nt_runtime_data * rtdata;
+ nt_argv_envp_block_info main_params_internal;
+ nt_argv_envp_block_info * main_params;
+ nt_get_argv_envp_ext_params * __ext_params;
+ ntapi_internals * __internals;
+
+ unsigned idx;
+ int32_t status;
+ uintptr_t addr;
+ intptr_t offset;
+ wchar16_t * wch_s;
+ wchar16_t * wch_dst;
+ wchar16_t ** wch_p;
+ char ** ch_p;
+ uintptr_t * psrc;
+ uintptr_t * pdst;
+ uintptr_t * paligned;
+ wchar16_t * pboundary;
+
+ /* init */
+ __internals = __ntapi_internals();
+
+ /* use internal buffer? */
+ if (flags & NT_GET_ARGV_ENVP_USE_CALLER_BUFFER) {
+ __ext_params = (nt_get_argv_envp_ext_params *)ext_params;
+ main_params = &(__ext_params->argv_envp_block_info);
+ } else {
+ /* pointers to internal/local structures */
+ main_params = &main_params_internal;
+
+ /* init */
+ __ntapi->tt_aligned_block_memset(
+ main_params,0,
+ sizeof(*main_params));
+
+ /* use internal buffer */
+ main_params->cmd_line = __ntapi_tt_get_cmd_line_utf16();
+ main_params->wargv_buffer = __internals->ntapi_img_sec_bss->argv_envp_array;
+ main_params->wargv_buffer_len = __NT_BSS_ARGV_BUFFER_SIZE;
+ main_params->argv_envp_ptr_total = (int)(main_params->wargv_buffer_len
+ / sizeof(uintptr_t));
+ main_params->wargs_buffer = (wchar16_t *)&(__internals->ntapi_img_sec_bss->args_envs_buffer);
+ main_params->wargs_buffer_len = __NT_BSS_ARGS_BUFFER_SIZE;
+ }
+
+ /* (__ntapi_parse_cmd_line_args_utf16 will zero-out both buffers) */
+ status = __ntapi_tt_parse_cmd_line_args_utf16(
+ main_params->cmd_line,
+ &main_params->argc,
+ main_params->wargs_buffer,
+ main_params->wargs_buffer_len,
+ &main_params->wargs_bytes_written,
+ main_params->wargv_buffer,
+ main_params->wargv_buffer_len,
+ 0);
+
+ if (status) return status;
+
+ /* argv[] needs a terminating null pointer */
+ if (main_params->argc == main_params->argv_envp_ptr_total)
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ /* set idx to the envp[0] array index */
+ idx = main_params->argc + 1;
+
+ /* set wenvp[] to its starting address */
+ main_params->wenvp_buffer = &main_params->wargv_buffer[idx];
+
+ /* update wargv_buffer_len and envp_buffer_len */
+ main_params->wenvp_buffer_len = main_params->wargv_buffer_len
+ - (idx * sizeof(uintptr_t));
+
+ main_params->wargv_buffer_len = idx * sizeof(uintptr_t);
+
+ /* align wenvs at pointer-size boundary */
+ main_params->wargs_bytes_written += sizeof(uintptr_t) - 1;
+ main_params->wargs_bytes_written /= sizeof(uintptr_t);
+ main_params->wargs_bytes_written *= sizeof(uintptr_t);
+
+ /* book-keeping */
+ main_params->wenvs_buffer = main_params->wargs_buffer
+ + main_params->wargs_bytes_written;
+
+ main_params->wenvs_buffer_len = main_params->wargs_buffer_len
+ - main_params->wargs_bytes_written;
+
+ main_params->wargs_buffer_len = main_params->wargs_bytes_written;
+
+
+ /* peb environment block (read-only) */
+ wch_s = __ntapi_tt_get_peb_env_block_utf16();
+
+ if ((!wch_s) || (!*wch_s))
+ return NT_STATUS_DLL_INIT_FAILED;
+
+ /* populate the envp[] array */
+ while ((*wch_s) && (idx < main_params->argv_envp_ptr_total)) {
+ main_params->envc++;
+ wch_p = &(main_params->wargv_buffer[idx]);
+ *wch_p = wch_s;
+
+ /* skip the rest of the environment variable */
+ while (*++wch_s);
+
+ /* advance to the next variable (or final null termination) */
+ wch_s++;
+ idx++;
+ }
+
+ /* envp[] needs a terminating null pointer */
+ if ((*wch_s) && (idx = main_params->argv_envp_ptr_total))
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ /* copy environment? */
+ if (flags & NT_GET_ARGV_ENVP_COPY_ENVIRONMENT) {
+ /* wch_s now points at the final null termination */
+ main_params->wenvs_bytes_used =
+ ((uintptr_t)wch_s
+ - (uintptr_t)(*main_params->wenvp_buffer));
+
+ /* do we have enough room? */
+ if (main_params->wenvs_buffer_len < main_params->wenvs_bytes_used)
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ /* upper boundary */
+ pboundary = ++wch_s;
+
+ /* you'd expect the peb environment block to be aligned,
+ but one can never know... */
+ wch_s = *main_params->wenvp_buffer;
+ wch_dst = main_params->wenvs_buffer;
+
+ while ((uintptr_t)wch_s % sizeof(uintptr_t)) {
+ *wch_dst = *wch_s;
+ wch_s++;
+ wch_dst++;
+ }
+
+ /* copy the aligned portion of the environment block */
+ addr = (uintptr_t)(pboundary);
+ addr /= sizeof(uintptr_t);
+ addr *= sizeof(uintptr_t);
+ paligned = (uintptr_t *)addr;
+
+ psrc = (uintptr_t *)wch_s;
+ pdst = (uintptr_t *)wch_dst;
+
+ while (psrc < paligned) {
+ *pdst = *psrc;
+ psrc++;
+ pdst++;
+ }
+
+ /* copy any remaining bytes */
+ wch_s = (wchar16_t *)paligned;
+ wch_dst = (wchar16_t *)pdst;
+
+ while (wch_s < pboundary) {
+ *wch_dst = *wch_s;
+ wch_s++;
+ wch_dst++;
+ }
+
+ /* finally, we update the envp[] pointers */
+ offset = (intptr_t)main_params->wenvs_buffer
+ - (intptr_t)*main_params->wenvp_buffer;
+
+ wch_p = main_params->wenvp_buffer;
+
+ while (*wch_p) {
+ addr = ((uintptr_t)*wch_p) + offset;
+ *wch_p = (wchar16_t *)addr;
+ wch_p++;
+ }
+ }
+
+ /* (command line arguments always get validated) */
+ /* validate the environment block? */
+ if (flags & NT_GET_ARGV_ENVP_VALIDATE_UTF16) {
+ wch_p = main_params->wenvp_buffer;
+
+ while (*wch_p) {
+ status = __ntapi->uc_validate_unicode_stream_utf16(
+ *wch_p,
+ 0,0,0,0,0);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+ else
+ wch_p++;
+ }
+ }
+
+ /* once */
+ if (!__internals->rtdata) {
+ __ntapi->tt_get_runtime_data(
+ &__internals->rtdata,
+ main_params->wargv_buffer);
+
+ if (!__internals->rtdata) {
+ __internals->rtdata = &__rtdata;
+
+ if ((status =__ntapi->tt_init_runtime_data(&__rtdata)))
+ return status;
+
+ } else if ((status =__ntapi->tt_update_runtime_data(__internals->rtdata)))
+ return status;
+
+ rtdata = __internals->rtdata;
+
+ rtdata->peb_envc = main_params->envc;
+ rtdata->peb_argc = main_params->argc;
+ rtdata->peb_wargv = main_params->wargv_buffer;
+ rtdata->peb_wenvp = main_params->wenvp_buffer;
+
+ /* integral wargv, wenvp, argv, envp */
+ if (rtdata->wargv) {
+ rtdata->wargv += (uintptr_t)rtdata / sizeof(wchar16_t *);
+
+ for (wch_p=rtdata->wargv; *wch_p; wch_p++)
+ *wch_p += (uintptr_t)rtdata / sizeof(wchar16_t);
+ };
+
+ if (rtdata->wenvp) {
+ rtdata->wenvp += (uintptr_t)rtdata / sizeof(wchar16_t *);
+
+ for (wch_p=rtdata->wenvp; *wch_p; wch_p++)
+ *wch_p += (uintptr_t)rtdata / sizeof(wchar16_t);
+ }
+
+ if (rtdata->argv) {
+ rtdata->argv += (uintptr_t)rtdata / sizeof(char *);
+
+ for (ch_p=rtdata->argv; *ch_p; ch_p++)
+ *ch_p += (uintptr_t)rtdata;
+
+ rtdata->argc = (int32_t)(ch_p - rtdata->argv);
+ };
+
+ if (rtdata->envp) {
+ rtdata->envp += (uintptr_t)rtdata / sizeof(char *);
+
+ for (ch_p=rtdata->envp; *ch_p; ch_p++)
+ *ch_p += (uintptr_t)rtdata;
+
+ rtdata->envc = (int32_t)(ch_p - rtdata->envp);
+ };
+ }
+
+ /* we're good */
+ *argc = main_params->argc;
+ *wargv = main_params->wargv_buffer;
+ *wenvp = main_params->wenvp_buffer;
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+int32_t __stdcall __ntapi_tt_get_argv_envp_utf8(
+ __out int * argc,
+ __out char *** argv,
+ __out char *** envp,
+ __in uint32_t flags,
+ __in void * ext_params __optional,
+ __out void * reserved __optional)
+{
+ int32_t status;
+ ntapi_internals * __internals;
+
+ wchar16_t ** wargv;
+ wchar16_t ** wenvp;
+ uint32_t pcount;
+
+ nt_get_argv_envp_ext_params __ext_params_internal;
+ nt_get_argv_envp_ext_params * __ext_params;
+ nt_argv_envp_block_info * main_params;
+
+ /* use internal buffer? */
+ if (flags & NT_GET_ARGV_ENVP_USE_CALLER_BUFFER) {
+ __ext_params = (nt_get_argv_envp_ext_params *)ext_params;
+ main_params = &__ext_params->argv_envp_block_info;
+ } else {
+ /* pointers to internal/local structures */
+ __ext_params = &__ext_params_internal;
+ main_params = &__ext_params->argv_envp_block_info;
+
+ /* init */
+ __ntapi->tt_aligned_block_memset(
+ main_params,0,
+ sizeof(*main_params));
+
+ __internals = __ntapi_internals();
+
+ /* use internal buffer */
+ main_params->cmd_line = __ntapi_tt_get_cmd_line_utf16();
+ main_params->wargv_buffer = __internals->ntapi_img_sec_bss->argv_envp_array;
+ main_params->wargv_buffer_len = __NT_BSS_ARGV_BUFFER_SIZE;
+ main_params->argv_envp_ptr_total = (int)(main_params->wargv_buffer_len
+ / sizeof(uintptr_t));
+ main_params->wargs_buffer = (wchar16_t *)&(__internals->ntapi_img_sec_bss->args_envs_buffer);
+ main_params->wargs_buffer_len = __NT_BSS_ARGS_BUFFER_SIZE;
+ }
+
+ /* start with obtaining the utf-16 environment */
+ status = __ntapi->tt_get_argv_envp_utf16(
+ argc,
+ &wargv,
+ &wenvp,
+ flags | NT_GET_ARGV_ENVP_USE_CALLER_BUFFER,
+ __ext_params,
+ reserved);
+
+ if (status) return status;
+
+ /* enough pointers left? */
+ pcount = main_params->argc + 1 + main_params->envc + 1;
+
+ if (pcount > (main_params->argv_envp_ptr_total / 2))
+ return NT_STATUS_BUFFER_TOO_SMALL;
+ else if ((main_params->wenvs_buffer_len - main_params->wenvs_bytes_used)
+ < sizeof(uintptr_t))
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ /* first args byte should be aligned at pointer-size boundary */
+ main_params->wenvs_bytes_used += sizeof(uintptr_t) - 1;
+ main_params->wenvs_bytes_used /= sizeof(uintptr_t);
+ main_params->wenvs_bytes_used *= sizeof(uintptr_t);
+
+ /* book-keeping */
+ /* block reminder: wargs -- wenvs -- args -- envs */
+ main_params->argv = (char **)main_params->wenvp_buffer;
+ main_params->argv += main_params->envc + 1;
+
+ main_params->args_buffer = (char *)main_params->wenvs_buffer;
+ main_params->args_buffer += main_params->wenvs_bytes_used;
+
+ main_params->args_buffer_len = main_params->wenvs_buffer_len
+ - main_params->wenvs_bytes_used;
+
+ main_params->wenvs_buffer_len = main_params->wenvs_bytes_used;
+
+ /* create a utf-8 argv[] array */
+ status = __ntapi_tt_array_convert_utf16_to_utf8(
+ main_params->wargv_buffer,
+ main_params->argv,
+ 0,
+ main_params->args_buffer,
+ main_params->args_buffer_len,
+ &main_params->args_bytes_written);
+
+ if (status) return status;
+
+ /* first envs byte should be aligned to pointer-size boundary */
+ main_params->args_bytes_written += sizeof(uintptr_t) - 1;
+ main_params->args_bytes_written /= sizeof(uintptr_t);
+ main_params->args_bytes_written *= sizeof(uintptr_t);
+
+ /* book-keeping */
+ main_params->envp = main_params->argv + main_params->argc + 1;
+
+ main_params->envs_buffer = main_params->args_buffer
+ + main_params->args_bytes_written;
+
+ main_params->envs_buffer_len = main_params->args_buffer_len
+ - main_params->args_bytes_written;
+
+ main_params->args_buffer_len = main_params->args_bytes_written;
+
+ /* subsequent streams (if any) should be aligned to pointer-size boundary */
+ main_params->envs_bytes_used += sizeof(uintptr_t) - 1;
+ main_params->envs_bytes_used /= sizeof(uintptr_t);
+ main_params->envs_bytes_used *= sizeof(uintptr_t);
+
+ /* create a utf-8 envp[] array */
+ status = __ntapi_tt_array_convert_utf16_to_utf8(
+ main_params->wenvp_buffer,
+ main_params->envp,
+ 0,
+ main_params->envs_buffer,
+ main_params->envs_buffer_len,
+ &main_params->envs_bytes_used);
+
+ if (status) return status;
+
+ /* we're good */
+ *argc = main_params->argc;
+ *argv = main_params->argv;
+ *envp = main_params->envp;
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+wchar16_t * __stdcall __ntapi_tt_get_cmd_line_utf16(void)
+{
+ nt_peb * peb;
+ nt_unicode_string cmd_line;
+
+ peb = (nt_peb *)pe_get_peb_address();
+
+ if (peb) {
+ cmd_line = peb->process_params->command_line;
+ return cmd_line.buffer;
+ } else
+ return (wchar16_t *)0;
+}
+
+
+wchar16_t * __stdcall __ntapi_tt_get_peb_env_block_utf16(void)
+{
+ nt_peb * peb;
+
+ peb = (nt_peb *)pe_get_peb_address();
+
+ if (peb)
+ return peb->process_params->environment;
+ else
+ return (wchar16_t *)0;
+}
diff --git a/src/argv/ntapi_tt_array_utf16.c b/src/argv/ntapi_tt_array_utf16.c
new file mode 100644
index 0000000..d8bbb8b
--- /dev/null
+++ b/src/argv/ntapi_tt_array_utf16.c
@@ -0,0 +1,258 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <pemagine/pemagine.h>
+#include <ntapi/nt_argv.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+/**
+ * scenario: program -e app [arg1 arg2 ... argn]
+ * input: a utf-16 argument vector
+ * output: a utf-16 cmd_line string
+ * example: tty_pipe_create_child_process
+**/
+
+int32_t __stdcall __ntapi_tt_array_copy_utf16(
+ __out int * argc,
+ __in const wchar16_t ** wargv,
+ __in const wchar16_t ** wenvp,
+ __in const wchar16_t * image_name __optional,
+ __in const wchar16_t * interpreter __optional,
+ __in const wchar16_t * optarg __optional,
+ __in void * base,
+ __out void * buffer,
+ __in size_t buflen,
+ __out size_t * blklen)
+{
+ const wchar16_t ** parg;
+ const wchar16_t * warg;
+ const wchar16_t * dummy;
+ wchar16_t * wch;
+ ptrdiff_t diff;
+ ptrdiff_t ptrs;
+ size_t needed;
+
+ /* fallback */
+ dummy = 0;
+ wargv = wargv ? wargv : &dummy;
+ wenvp = wenvp ? wenvp : &dummy;
+
+ /* ptrs, needed */
+ ptrs = 0;
+ needed = 0;
+
+ if (image_name) {
+ ptrs++;
+ needed += sizeof(wchar16_t *)
+ + __ntapi->tt_string_null_offset_short((const int16_t *)image_name)
+ + sizeof(wchar16_t);
+ }
+
+ for (parg=wargv; *parg; parg++)
+ needed += sizeof(wchar16_t *)
+ + __ntapi->tt_string_null_offset_short((const int16_t *)*parg)
+ + sizeof(wchar16_t);
+
+ ptrs += (parg - wargv);
+ *argc = (int)ptrs;
+
+ for (parg=wenvp; *parg; parg++)
+ needed += sizeof(wchar16_t *)
+ + __ntapi->tt_string_null_offset_short((const int16_t *)*parg)
+ + sizeof(wchar16_t);
+
+ ptrs += (parg - wenvp);
+
+ ptrs += 2;
+ needed += 2*sizeof(wchar16_t *);
+ blklen = blklen ? blklen : &needed;
+ *blklen = needed;
+
+ if (buflen < needed)
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ /* init */
+ parg = (const wchar16_t **)buffer;
+ wch = (wchar16_t *)(parg+ptrs);
+ diff = (uintptr_t)base / sizeof(wchar16_t);
+
+ /* image_name */
+ if (image_name) {
+ *parg++ = wch-diff;
+ for (warg=image_name; *warg; warg++,wch++)
+ *wch = *warg;
+ *wch++ = '\0';
+ }
+
+ /* argv */
+ for (; *wargv; wargv++) {
+ *parg++=wch-diff;
+ for (warg=*wargv; *warg; warg++,wch++)
+ *wch = *warg;
+ *wch++ = '\0';
+ }
+
+ *parg++ = 0;
+
+ /* envp */
+ for (; *wenvp; wenvp++) {
+ *parg++=wch-diff;
+ for (warg=*wenvp; *warg; warg++,wch++)
+ *wch = *warg;
+ *wch++ = '\0';
+ }
+
+ *parg++ = 0;
+
+ return NT_STATUS_SUCCESS;
+}
+
+int32_t __stdcall __ntapi_tt_array_convert_utf16_to_utf8(
+ __in wchar16_t ** warrv,
+ __in char ** arrv,
+ __in void * base,
+ __in char * buffer,
+ __in size_t buffer_len,
+ __out size_t * bytes_written)
+{
+ uint8_t * ubound;
+ uint8_t * ch;
+ wchar16_t * wch;
+ wchar16_t wx;
+ wchar16_t wy;
+ wchar16_t wz;
+ wchar16_t wy_low;
+ wchar16_t wy_high;
+ wchar16_t ww;
+ wchar16_t uuuuu;
+ wchar16_t u_low;
+ wchar16_t u_high;
+ ptrdiff_t diff;
+
+ #define __UTF8_MAX_CODE_POINT_BYTES (4)
+
+ ch = (uint8_t *)buffer;
+ ubound = (uint8_t *)buffer + buffer_len - __UTF8_MAX_CODE_POINT_BYTES;
+ diff = (uintptr_t)base / sizeof(wchar16_t);
+
+ while (warrv && *warrv) {
+ *arrv = (char *)(ch-(uintptr_t)base);
+ wch = *warrv + diff;
+
+ /* all utf-16 streams at stake have been validated */
+ while (*wch && (ch < ubound)) {
+ if (*wch <= 0x7F) {
+ /* from: 00000000 0xxxxxxx (little endian) */
+ /* to: 0xxxxxxx (utf-8) */
+ *ch = (char)(*wch);
+ } else if (*wch <= 0x7FF) {
+ /* from: 00000yyy yyxxxxxx (little endian) */
+ /* to: 110yyyyy 10xxxxxx (utf-8) */
+ wy = *wch;
+ wy >>= 6;
+
+ wx = *wch;
+ wx <<= 10;
+ wx >>= 10;
+
+ /* write the y part */
+ *ch = (char)(0xC0 | wy);
+ ch++;
+
+ /* write the x part */
+ *ch = (char)(0x80 | wx);
+ } else if ((*wch < 0xD800) || (*wch >= 0xE000)) {
+ /* from: zzzzyyyy yyxxxxxx (little endian) */
+ /* to: 1110zzzz 10yyyyyy 10xxxxxx (utf-8) */
+ wz = *wch;
+ wz >>= 12;
+
+ wy = *wch;
+ wy <<= 4;
+ wy >>= 10;
+
+ wx = *wch;
+ wx <<= 10;
+ wx >>= 10;
+
+ /* write the z part */
+ *ch = (char)(0xE0 | wz);
+ ch++;
+
+ /* write the y part */
+ *ch = (char)(0x80 | wy);
+ ch++;
+
+ /* write the x part */
+ *ch = (char)(0x80 | wx);
+ } else {
+ /* from: 110110ww wwzzzzyy 110111yy yyxxxxxx (little endian) */
+ /* to: 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx (utf-8) */
+
+ /* low two bytes */
+ wx = *wch;
+ wx <<= 10;
+ wx >>= 10;
+
+ wy_low = *wch;
+ wy_low <<= 6;
+ wy_low >>= 12;
+
+ /* (surrogate pair) */
+ wch++;
+
+ /* high two bytes */
+ wy_high = *wch;
+ wy_high <<= 14;
+ wy_high >>= 10;
+
+ wz = *wch;
+ wz <<= 10;
+ wz >>= 12;
+ wz <<= 2;
+
+ ww = *wch;
+ ww <<= 6;
+ ww >>= 12;
+
+ uuuuu = ww + 1;
+ u_high = uuuuu >> 2;
+ u_low = ((uuuuu << 14) >> 10);
+
+ /* 1st byte: 11110uuu */
+ *ch = (char)(0xF0 | u_high);
+ ch++;
+
+ /* 2nd byte: 10uuzzzz */
+ *ch = (char)(0x80 | u_low | wz);
+ ch++;
+
+ /* 3rd byte: 10yyyyyy */
+ *ch = (char)(0x80 | wy_low | wy_high);
+ ch++;
+
+ /* 4th byte: 10xxxxxx */
+ *ch = (char)(0x80 | wx);
+ }
+
+ ch++;
+ wch++;
+ }
+
+ if (*wch)
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ ch++;
+ arrv++;
+ warrv++;
+ }
+
+ *bytes_written = (size_t)(ch - (uint8_t *)buffer);
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/argv/ntapi_tt_array_utf8.c b/src/argv/ntapi_tt_array_utf8.c
new file mode 100644
index 0000000..8d3b837
--- /dev/null
+++ b/src/argv/ntapi_tt_array_utf8.c
@@ -0,0 +1,117 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <pemagine/pemagine.h>
+#include <ntapi/nt_argv.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tt_array_copy_utf8(
+ __out int * argc,
+ __in const char ** argv,
+ __in const char ** envp,
+ __in const char * image_name __optional,
+ __in const char * interpreter __optional,
+ __in const char * optarg __optional,
+ __in void * base,
+ __out void * buffer,
+ __in size_t buflen,
+ __out size_t * blklen)
+{
+ const char ** parg;
+ const char * arg;
+ const char * dummy;
+ char * ch;
+ ptrdiff_t diff;
+ ptrdiff_t ptrs;
+ size_t needed;
+
+ /* fallback */
+ dummy = 0;
+ argv = argv ? argv : &dummy;
+ envp = envp ? envp : &dummy;
+
+ /* ptrs, needed */
+ ptrs = 0;
+ needed = 0;
+
+ if (image_name) {
+ ptrs++;
+ needed += sizeof(char *)
+ + __ntapi->tt_string_null_offset_multibyte(image_name)
+ + sizeof(char);
+ }
+
+ for (parg=argv; *parg; parg++)
+ needed += sizeof(char *)
+ + __ntapi->tt_string_null_offset_multibyte(*parg)
+ + sizeof(char);
+
+ ptrs += (parg - argv);
+ *argc = (int)ptrs;
+
+ for (parg=envp; *parg; parg++)
+ needed += sizeof(char *)
+ + __ntapi->tt_string_null_offset_multibyte(*parg)
+ + sizeof(char);
+
+ ptrs += (parg - envp);
+
+ ptrs += 2;
+ needed += 2*sizeof(char *);
+ blklen = blklen ? blklen : &needed;
+ *blklen = needed;
+
+ if (buflen < needed)
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ /* init */
+ parg = (const char **)buffer;
+ ch = (char *)(parg+ptrs);
+ diff = (ptrdiff_t)base;
+
+ /* image_name */
+ if (image_name) {
+ *parg++ = ch-diff;
+ for (arg=image_name; *arg; arg++,ch++)
+ *ch = *arg;
+ *ch++ = '\0';
+ }
+
+ /* argv */
+ for (; *argv; argv++) {
+ *parg++=ch-diff;
+ for (arg=*argv; *arg; arg++,ch++)
+ *ch = *arg;
+ *ch++ = '\0';
+ }
+
+ *parg++ = 0;
+
+ /* envp */
+ for (; *envp; envp++) {
+ *parg++=ch-diff;
+ for (arg=*envp; *arg; arg++,ch++)
+ *ch = *arg;
+ *ch++ = '\0';
+ }
+
+ *parg++ = 0;
+
+ return NT_STATUS_SUCCESS;
+}
+
+int32_t __stdcall __ntapi_tt_array_convert_utf8_to_utf16(
+ __in char ** arrv,
+ __in wchar16_t ** arra,
+ __in void * base,
+ __in wchar16_t * buffer,
+ __in size_t buffer_len,
+ __out size_t * bytes_written)
+{
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/argv/ntapi_tt_env_vars.c b/src/argv/ntapi_tt_env_vars.c
new file mode 100644
index 0000000..1af9b77
--- /dev/null
+++ b/src/argv/ntapi_tt_env_vars.c
@@ -0,0 +1,112 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tt_get_env_var_meta_utf16(
+ __in const uint32_t * crc32_table,
+ __in wchar16_t * env_var_name,
+ __in uint32_t env_var_name_hash __optional,
+ __in wchar16_t ** envp,
+ __out nt_env_var_meta_utf16 * env_var_meta)
+{
+ int idx;
+ uint32_t crc32;
+ unsigned char * byte_buffer;
+ wchar16_t * wch;
+
+ #define EQUAL_SIGN 0x3D
+
+ /* step 1: crc32 of the target env_var_name */
+ if (env_var_name_hash)
+ crc32 = env_var_name_hash;
+ else {
+ crc32 = 0 ^ 0xFFFFFFFF;
+
+ /* initialize byte_buffer */
+ byte_buffer = (unsigned char *)env_var_name;
+
+ /* iterate */
+ while (*byte_buffer) {
+ /* two bytes at a time */
+ crc32 = (crc32 >> 8) ^ crc32_table[(crc32 ^ *byte_buffer) & 0xFF];
+ byte_buffer++;
+ crc32 = (crc32 >> 8) ^ crc32_table[(crc32 ^ *byte_buffer) & 0xFF];
+ byte_buffer++;
+ }
+ crc32 = (crc32 ^ 0xFFFFFFFF);
+ }
+
+ /* initialize the env_var_meta structure */
+ env_var_meta->name_hash = crc32;
+ env_var_meta->name = (wchar16_t *)0;
+ env_var_meta->value = (wchar16_t *)0;
+ env_var_meta->value_hash = 0;
+ env_var_meta->envp_index = 0;
+ env_var_meta->flags = 0;
+
+ /* step 2: look for the environment variable in envp[] */
+ idx = 0;
+ while (envp[idx] && (!env_var_meta->value)) {
+ wch = envp[idx];
+
+ /* find the equal sign */
+ while ((*wch) && (*wch != EQUAL_SIGN))
+ wch++;
+
+ if (*wch != EQUAL_SIGN)
+ return NT_STATUS_ILLEGAL_CHARACTER;
+
+ /* hash the current environment variable */
+ crc32 = 0 ^ 0xFFFFFFFF;
+
+ /* initialize byte_buffer */
+ byte_buffer = (unsigned char *)envp[idx];
+
+ /* iterate */
+ while ((uintptr_t)(byte_buffer) < (uintptr_t)wch) {
+ /* two bytes at a time */
+ crc32 = (crc32 >> 8) ^ crc32_table[(crc32 ^ *byte_buffer) & 0xFF];
+ byte_buffer++;
+ crc32 = (crc32 >> 8) ^ crc32_table[(crc32 ^ *byte_buffer) & 0xFF];
+ byte_buffer++;
+ }
+
+ if (env_var_meta->name_hash == (crc32 ^ 0xFFFFFFFF)) {
+ /* found it, get ready to hash the value */
+ wch++;
+ env_var_meta->name = envp[idx];
+ env_var_meta->value = wch;
+ env_var_meta->envp_index = idx;
+ } else {
+ idx++;
+ }
+ }
+
+ if (env_var_meta->value) {
+ /* hash the value: utf-16, null-terminated */
+ crc32 = 0 ^ 0xFFFFFFFF;
+
+ /* initialize byte_buffer */
+ byte_buffer = (unsigned char *)env_var_meta->value;
+
+ /* iterate */
+ while (*byte_buffer) {
+ /* two bytes at a time */
+ crc32 = (crc32 >> 8) ^ crc32_table[(crc32 ^ *byte_buffer) & 0xFF];
+ byte_buffer++;
+ crc32 = (crc32 >> 8) ^ crc32_table[(crc32 ^ *byte_buffer) & 0xFF];
+ byte_buffer++;
+ }
+
+ env_var_meta->value_hash = (crc32 ^ 0xFFFFFFFF);
+ }
+
+ return NT_STATUS_SUCCESS;
+}
+
diff --git a/src/argv/ntapi_tt_get_option.c b/src/argv/ntapi_tt_get_option.c
new file mode 100644
index 0000000..e6f0748
--- /dev/null
+++ b/src/argv/ntapi_tt_get_option.c
@@ -0,0 +1,451 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+
+/**
+ * a simple facility for minimal programs or system libraries
+ * with no libc available at the time of invocation, as well
+ * as applications using the midipix free-standing development
+ * environment.
+ *
+ * the approach taken by this module to the support of short
+ * and long options reflects the above constraint, namely
+ * the absence of a callable libc at the time of invocation;
+ * there is no intent for interfaces in this module to
+ * be POSIXLY correct or otherwise portable. the sole
+ * purpose of all functions in this module is to serve
+ * internal or otherwise free-standing midipix applications,
+ * and their relevance otherwise is accordingly non-existent.
+ *
+ * all options are encoded in utf-16; note, however, that
+ * short options may only use code points that are located
+ * in the basic multilingual plane.
+ *
+ * option values are either required or not allowed altogether,
+ * and the first character of an option value may not be a hyphen.
+ * if you need the first character of an option value to be a
+ * hyphen, then make sure you escape it somehow (for instance by
+ * enclosing it in quotation marks).
+ *
+ * a short option and its value must reside in two separate
+ * argv[] elements (in other words: -ooutput is illegal).
+ *
+ * a long option and its value must reside in the same argv[]
+ * element and be separated by a single equal sign.
+ *
+ * Examples of valid options and option values:
+ * --------------------------------------------
+ * -o
+ * -o value
+ * --long-option-with-no-value
+ * --long-option=value
+**/
+
+#define HYPHEN 0x2D
+#define EQUAL_SIGN 0x3D
+
+
+static int __inline__ __fastcall __is_bmp_code_point(wchar16_t code_point)
+{
+ return (((code_point >= 0x0000) && (code_point < 0xD800)) \
+ || ((code_point >= 0xE000) && (code_point < 0x10000)));
+}
+
+
+static int __inline__ __fastcall __is_last_program_option(
+ __in nt_program_option * option)
+{
+ return (!(option->short_name_code))
+ && (!(option->long_name))
+ && (!(option->long_name_hash));
+}
+
+
+static int __fastcall __is_short_option(wchar16_t * wch)
+{
+ return ((wch) && (*wch == HYPHEN)
+ && __is_bmp_code_point(*++wch)
+ && (*++wch == 0));
+}
+
+static int __fastcall __is_long_option(wchar16_t * wch)
+{
+ return ((wch) && (*wch == HYPHEN)
+ && (++wch) && (*wch == HYPHEN)
+ && (*++wch));
+}
+
+
+static int __fastcall __is_last_option_argument(wchar16_t * wch)
+{
+ return ((wch) && (*wch == HYPHEN)
+ && (*++wch == HYPHEN)
+ && (*++wch == 0));
+}
+
+
+static uint32_t __fastcall __compute_crc32_utf16_str(
+ __in const uint32_t * crc32_table,
+ __in wchar16_t * wch)
+{
+ uint32_t crc32;
+ unsigned char * byte_buffer;
+
+ /* crc32 hash... */
+ crc32 = 0 ^ 0xFFFFFFFF;
+
+ /* initialize byte_buffer */
+ byte_buffer = (unsigned char *)wch;
+
+ /* iterate */
+ while (*byte_buffer) {
+ /* two bytes at a time */
+ crc32 = (crc32 >> 8) ^ crc32_table[(crc32 ^ *byte_buffer) & 0xFF];
+ byte_buffer++;
+ crc32 = (crc32 >> 8) ^ crc32_table[(crc32 ^ *byte_buffer) & 0xFF];
+ byte_buffer++;
+ }
+
+ return crc32;
+}
+
+
+static uint32_t __fastcall __compute_crc32_long_option_name(
+ __in const uint32_t * crc32_table,
+ __in wchar16_t * wch_arg,
+ __in wchar16_t * wch_termination)
+{
+ uint32_t crc32;
+ unsigned char * byte_buffer;
+
+ /* crc32 hash... */
+ crc32 = 0 ^ 0xFFFFFFFF;
+
+ /* initialize byte_buffer */
+ byte_buffer = (unsigned char *)wch_arg;
+
+ /* iterate */
+ while ((uintptr_t)byte_buffer < (uintptr_t)wch_termination) {
+ /* two bytes at a time */
+ crc32 = (crc32 >> 8) ^ crc32_table[(crc32 ^ *byte_buffer) & 0xFF];
+ byte_buffer++;
+ crc32 = (crc32 >> 8) ^ crc32_table[(crc32 ^ *byte_buffer) & 0xFF];
+ byte_buffer++;
+ }
+
+ return crc32;
+}
+
+
+static void __fastcall __init_cmd_option_meta_utf16(
+ __in nt_cmd_option_meta_utf16 * cmd_opt_meta)
+{
+ cmd_opt_meta->short_name = (wchar16_t *)0;
+ cmd_opt_meta->short_name_code = 0;
+ cmd_opt_meta->long_name = (wchar16_t *)0;
+ cmd_opt_meta->long_name_hash = 0;
+ cmd_opt_meta->value = (wchar16_t *)0;
+ cmd_opt_meta->value_hash = 0;
+ cmd_opt_meta->argv_index = 0;
+ cmd_opt_meta->flags = 0;
+
+ return;
+}
+
+
+int32_t __stdcall __ntapi_tt_get_short_option_meta_utf16(
+ __in const uint32_t * crc32_table,
+ __in wchar16_t option_name,
+ __in wchar16_t * argv[],
+ __out nt_cmd_option_meta_utf16 * cmd_opt_meta)
+{
+ int idx;
+ wchar16_t * wch;
+
+ if (!crc32_table)
+ return NT_STATUS_INVALID_PARAMETER_1;
+ else if (!option_name)
+ return NT_STATUS_INVALID_PARAMETER_2;
+ else if (!argv)
+ return NT_STATUS_INVALID_PARAMETER_3;
+
+ /* initialize cmd_opt_meta */
+ __init_cmd_option_meta_utf16(cmd_opt_meta);
+
+ /* step 1: attempt to find the short option in argv[] */
+ idx = 0;
+ while (argv[idx] && (!cmd_opt_meta->short_name_code)) {
+ wch = argv[idx];
+
+ /* is this our option? */
+ if ((*wch == HYPHEN)
+ && (*++wch == option_name)
+ && (*++wch == 0)) {
+
+ /* found it, get ready to hash the value */
+ cmd_opt_meta->short_name_code = option_name;
+ cmd_opt_meta->short_name = argv[idx];
+ cmd_opt_meta->argv_index = idx;
+ } else {
+ idx++;
+ }
+ }
+
+ /* if the next argument is also an option (or is null), just exit */
+ idx++;
+ if ((!argv[idx]) || (*argv[idx] == HYPHEN))
+ return NT_STATUS_SUCCESS;
+
+ /* step 2: hash the value */
+ cmd_opt_meta->value = argv[idx];
+ cmd_opt_meta->value_hash =
+ __compute_crc32_utf16_str(
+ crc32_table,
+ argv[idx]);
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+int32_t __stdcall __ntapi_tt_get_long_option_meta_utf16(
+ __in const uint32_t * crc32_table,
+ __in wchar16_t * option_name,
+ __in uint32_t option_name_hash __optional,
+ __in wchar16_t * argv[],
+ __out nt_cmd_option_meta_utf16 * cmd_opt_meta)
+{
+ /**
+ * option_name must always include the two-hyphen prefix;
+ * and the option value must be preceded by an equal sign.
+ *
+ * the only valid long option forms in argv[] are therefore:
+ * --long-option
+ * --long-option=value
+ **/
+
+ int idx;
+ uint32_t crc32;
+ wchar16_t * wch;
+
+ /* validation */
+ if (!crc32_table)
+ return NT_STATUS_INVALID_PARAMETER_1;
+ else if ((!option_name) && (!option_name_hash))
+ return NT_STATUS_INVALID_PARAMETER;
+ else if ((option_name) && (option_name_hash))
+ return NT_STATUS_INVALID_PARAMETER_MIX;
+ else if (!argv)
+ return NT_STATUS_INVALID_PARAMETER_4;
+
+ /* initialize cmd_opt_meta */
+ __init_cmd_option_meta_utf16(cmd_opt_meta);
+
+ /* step 1: crc32 of the target option_name */
+ if (option_name_hash)
+ crc32 = option_name_hash;
+ else
+ option_name_hash =
+ __compute_crc32_utf16_str(
+ crc32_table,
+ option_name);
+
+ /* step 2: attempt to find the long option in argv[] */
+ idx = 0;
+ while (argv[idx] && (!cmd_opt_meta->value)) {
+ wch = argv[idx];
+
+ if (__is_long_option(wch)) {
+ /* find the equal sign or null termination */
+ while ((*wch) && (*wch != EQUAL_SIGN))
+ wch++;
+
+ crc32 = __compute_crc32_long_option_name(
+ crc32_table,
+ argv[idx],
+ wch);
+
+ if (crc32 == option_name_hash) {
+ /* found it, get ready to hash the value */
+ cmd_opt_meta->long_name_hash = option_name_hash;
+ cmd_opt_meta->long_name = argv[idx];
+ cmd_opt_meta->argv_index = idx;
+
+ if (*wch)
+ /* skip the equal sign */
+ wch++;
+
+ cmd_opt_meta->value = wch;
+ } else
+ idx++;
+ }
+ }
+
+ if (cmd_opt_meta->value)
+ cmd_opt_meta->value_hash =
+ __compute_crc32_utf16_str(
+ crc32_table,
+ cmd_opt_meta->value);
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+int32_t __stdcall __ntapi_tt_validate_program_options(
+ __in const uint32_t * crc32_table,
+ __in wchar16_t * argv[],
+ __in nt_program_option * options[],
+ __in nt_program_options_meta * options_meta)
+{
+ int idx;
+ int idx_arg;
+ int idx_option;
+ int idx_max;
+ uint32_t crc32;
+ nt_program_option * option;
+ wchar16_t * parg;
+ wchar16_t * pvalue;
+
+ /* validation */
+ if (!crc32_table)
+ return NT_STATUS_INVALID_PARAMETER_1;
+ else if (!argv)
+ return NT_STATUS_INVALID_PARAMETER_2;
+ else if (!options)
+ return NT_STATUS_INVALID_PARAMETER_3;
+ else if (!options_meta)
+ return NT_STATUS_INVALID_PARAMETER_4;
+
+
+ /* step 1: validate options[] hash the long option names */
+ idx = 0;
+ idx_option = 0;
+ option = options[0];
+ pvalue = (wchar16_t *)0;
+
+ while (!__is_last_program_option(option)) {
+ if (option->short_name_code) {
+ if (!(__is_bmp_code_point(option->short_name_code))) {
+ options_meta->idx_invalid_short_name = idx;
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+ }
+
+ if (option->long_name) {
+ if (!(__is_long_option(option->long_name))) {
+ options_meta->idx_invalid_long_name = idx;
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
+ /* update the long name hash (unconditionally) */
+ option->long_name_hash =
+ __compute_crc32_utf16_str(
+ crc32_table,
+ option->long_name);
+ }
+
+ idx++;
+ option++;
+ }
+
+ /* book keeping */
+ idx_max = idx;
+
+ /* step 2: validate argv[] */
+ parg = argv[0];
+ idx_arg = 0;
+
+ while ((parg) && (!(__is_last_option_argument(parg)))) {
+ if (__is_short_option(parg)) {
+ idx = 0;
+ idx_option = 0;
+
+ while ((idx < idx_max) && (!idx_option)) {
+ option = options[idx];
+
+ if (*(parg+1) == option->short_name_code)
+ idx_option = idx;
+ else
+ idx++;
+ }
+
+ if (idx == idx_max) {
+ options_meta->idx_invalid_argument = idx_arg;
+ return NT_STATUS_INVALID_PARAMETER;
+ } else {
+ /* get ready for the next element (or value) */
+ parg++;
+ idx_arg++;
+ pvalue = parg;
+ }
+ } else if (__is_long_option(parg)) {
+ idx = 0;
+ idx_option = 0;
+ /* find the equal sign or null termination */
+ pvalue = parg;
+ while ((*pvalue) && (*pvalue != EQUAL_SIGN))
+ pvalue++;
+
+ while ((idx < idx_max) && (!idx_option)) {
+ option = options[idx];
+ crc32 = __compute_crc32_long_option_name(
+ crc32_table,
+ parg,
+ pvalue);
+
+ if (crc32 == option->long_name_hash)
+ idx_option = idx;
+ else
+ idx++;
+ }
+
+ if (idx == idx_max) {
+ options_meta->idx_invalid_argument = idx_arg;
+ return NT_STATUS_INVALID_PARAMETER;
+ } else {
+ if (*pvalue != EQUAL_SIGN)
+ /* skip the equal sign */
+ pvalue++;
+ pvalue = (wchar16_t *)0;
+ }
+ }
+
+ /* validate the occurrence */
+ if (idx_option) {
+ if (option->flags && NT_OPTION_ALLOWED_ONCE) {
+ if (option->option_count) {
+ options_meta->idx_invalid_argument
+ = idx_arg;
+ return NT_STATUS_INVALID_PARAMETER;
+ } else {
+ option->option_count++;
+ }
+ }
+
+ if (option->flags && NT_OPTION_VALUE_REQUIRED) {
+ if ((!(*pvalue)) || (*pvalue == HYPHEN)) {
+ options_meta->idx_missing_option_value
+ = idx_arg;
+ return NT_STATUS_INVALID_PARAMETER;
+ } else {
+ option->value = pvalue;
+ option->value_hash =
+ __compute_crc32_utf16_str(
+ crc32_table,
+ option->value);
+ }
+ }
+ }
+
+ parg++;
+ idx_arg++;
+ }
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/blitter/ntapi_blt_alloc.c b/src/blitter/ntapi_blt_alloc.c
new file mode 100644
index 0000000..4ba6f2c
--- /dev/null
+++ b/src/blitter/ntapi_blt_alloc.c
@@ -0,0 +1,149 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_blitter.h>
+#include <ntapi/nt_sync.h>
+#include <ntapi/ntapi.h>
+#include <ntapi/nt_atomic.h>
+#include "ntapi_blitter.h"
+#include "ntapi_impl.h"
+
+static int __blt_popcount(uintptr_t mask)
+{
+ /* todo: check cpuid, use at_popcount */
+ int i,ret;
+
+ for (i=0,ret=0; i<8*sizeof(uintptr_t); i++)
+ if (mask & ((uintptr_t)1<<i))
+ ret++;
+
+ return ret;
+}
+
+
+int32_t __fastcall __ntapi_blt_alloc(
+ __out nt_blitter ** blitter,
+ __in nt_blitter_params * params)
+{
+ int32_t status;
+ nt_blitter * blt_ctx;
+ size_t blt_ctx_size;
+ size_t params_size;
+ size_t ptrs,i;
+
+ /* alignment */
+ if ((params->block_size % sizeof(uintptr_t)) || (params->block_count % sizeof(uintptr_t)))
+ return NT_STATUS_INVALID_PARAMETER;
+
+ /* blt control block allocation */
+ ptrs = params->block_count / (8 * sizeof(uintptr_t));
+ blt_ctx = (nt_blitter *)0;
+ blt_ctx_size = (size_t)&((nt_blitter *)0)->bits;
+
+ /* user-provided bitmap? */
+ if (!params->bitmap)
+ blt_ctx_size += ptrs * sizeof(uintptr_t);
+
+ /* alloc */
+ status = __ntapi->zw_allocate_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ (void **)&blt_ctx,
+ 0,
+ &blt_ctx_size,
+ NT_MEM_COMMIT,
+ NT_PAGE_READWRITE);
+
+ if (status) return (status);
+
+ /* init control block */
+ __ntapi->tt_aligned_block_memset(
+ blt_ctx,
+ 0,(size_t)&((nt_blitter *)0)->bits);
+
+ blt_ctx->addr = blt_ctx;
+ blt_ctx->size = blt_ctx_size;
+ blt_ctx->ptrs = ptrs;
+
+ /* init bitmap */
+ blt_ctx->bitmap = params->bitmap
+ ? (uintptr_t *)params->bitmap
+ : blt_ctx->bits;
+
+ if (!(params->flags & NT_BLITTER_PRESERVE_BITS))
+ __ntapi->tt_aligned_block_memset(
+ blt_ctx->bitmap,
+ (intptr_t)0xFFFFFFFFFFFFFFFF,
+ ptrs * sizeof(uintptr_t));
+
+ /* info structure */
+ blt_ctx->info.info_size = sizeof(nt_blitter_info);
+ blt_ctx->info.block_count = params->block_count;
+ blt_ctx->info.block_size = params->block_size;
+
+ if (params->flags & NT_BLITTER_ENABLE_BLOCK_ARRAY)
+ /* allocate in place */
+ blt_ctx->info.region_size = params->block_count * params->block_size;
+ else
+ /* use pointer array */
+ blt_ctx->info.region_size = params->block_count * sizeof(uintptr_t);
+
+ /* allocate region */
+ if (params->region)
+ blt_ctx->info.region_addr = params->region;
+ else
+ status = __ntapi->zw_allocate_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ &blt_ctx->info.region_addr,
+ 0,
+ &blt_ctx->info.region_size,
+ NT_MEM_COMMIT,
+ NT_PAGE_READWRITE);
+
+ if (status) {
+ __ntapi->blt_free(blt_ctx);
+ return status;
+ }
+
+ if (params->flags & NT_BLITTER_PRESERVE_BITS)
+ for (i=0,blt_ctx->info.blocks_avail=0; i<ptrs; i++)
+ blt_ctx->info.blocks_avail += __blt_popcount(blt_ctx->bitmap[i]);
+ else
+ blt_ctx->info.blocks_avail = params->block_count;
+
+ if (params->flags & NT_BLITTER_ENABLE_BLOCK_ARRAY)
+ blt_ctx->info.blocks_cached = params->block_count;
+
+ /* init block array */
+ if (!params->region)
+ __ntapi->tt_aligned_block_memset(
+ blt_ctx->info.region_addr,
+ 0,blt_ctx->info.region_size);
+
+ /* copy params */
+ if (params->params_size < sizeof(nt_blitter_params))
+ params_size = params->params_size;
+ else
+ params_size = sizeof(nt_blitter_params);
+
+ __ntapi->tt_aligned_block_memcpy(
+ (uintptr_t *)&blt_ctx->params,
+ (uintptr_t *)params,
+ params_size);
+
+ /* update params */
+ blt_ctx->params.lock_tries = params->lock_tries
+ ? params->lock_tries
+ : __NT_BLITTER_DEFAULT_LOCK_TRIES;
+
+ blt_ctx->params.round_trips = params->round_trips
+ ? params->round_trips
+ : __NT_BLITTER_DEFAULT_ROUND_TRIPS;
+
+ *blitter = blt_ctx;
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/blitter/ntapi_blt_block.c b/src/blitter/ntapi_blt_block.c
new file mode 100644
index 0000000..879eb1b
--- /dev/null
+++ b/src/blitter/ntapi_blt_block.c
@@ -0,0 +1,204 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_blitter.h>
+#include <ntapi/nt_sync.h>
+#include <ntapi/ntapi.h>
+#include <ntapi/nt_atomic.h>
+#include "ntapi_blitter.h"
+#include "ntapi_impl.h"
+
+static int32_t __fastcall __blt_bitbite(
+ __in nt_blitter * blitter,
+ __in unsigned int bit,
+ __in size_t byte)
+{
+ uint32_t locktry;
+ uintptr_t test;
+ uintptr_t cmp;
+ uintptr_t xchg;
+ uintptr_t mask;
+
+ mask = ((uintptr_t)1 << bit);
+ locktry = blitter->params.lock_tries;
+
+ for (; locktry; locktry--) {
+ cmp = blitter->bitmap[byte] | mask;
+ xchg = cmp ^ mask;
+
+ test = at_locked_cas(
+ (intptr_t *)&blitter->bitmap[byte],
+ cmp,xchg);
+
+ if (test == cmp) {
+ at_locked_dec(&blitter->info.blocks_avail);
+ at_locked_inc(&blitter->info.blocks_used);
+ return NT_STATUS_SUCCESS;
+
+ } else if (test ^ mask)
+ return NT_STATUS_TRANSACTIONAL_CONFLICT;
+ }
+
+ if (!locktry) {
+ blitter->info.busy = 1;
+ blitter->info.lock_tries = blitter->params.lock_tries;
+ return NT_STATUS_DEVICE_BUSY;
+ }
+
+ return NT_STATUS_MORE_PROCESSING_REQUIRED;
+}
+
+static int32_t __fastcall __blt_acquire(
+ __in nt_blitter * blitter,
+ __out intptr_t * blkid)
+{
+ unsigned int bit;
+ uintptr_t i,n;
+
+ if (blitter->info.blocks_avail == 0)
+ return NT_STATUS_ALLOCATE_BUCKET;
+
+ for (n=0,bit=0; blitter->info.blocks_avail && (n < blitter->params.round_trips); n++) {
+ for (i=*blkid/(8*sizeof(size_t)); (i<blitter->ptrs); i++)
+ if (at_bsf(&bit,blitter->bitmap[i]))
+ break;
+
+ if (i == blitter->ptrs)
+ return NT_STATUS_ALLOCATE_BUCKET;
+
+ switch (__blt_bitbite(blitter,bit,i)) {
+ case NT_STATUS_SUCCESS:
+ *blkid = bit + (i * 8 * sizeof(size_t));
+ return NT_STATUS_SUCCESS;
+
+ case NT_STATUS_DEVICE_BUSY:
+ return NT_STATUS_DEVICE_BUSY;
+
+ default:
+ break;
+ }
+ }
+
+ return NT_STATUS_ALLOCATE_BUCKET;
+}
+
+
+int32_t __fastcall __ntapi_blt_obtain(
+ __in nt_blitter * blitter,
+ __out intptr_t * blkid)
+{
+ unsigned int bit;
+ uintptr_t i,n;
+ uintptr_t mask;
+
+ if (blitter->info.blocks_avail == 0)
+ return NT_STATUS_ALLOCATE_BUCKET;
+ else if ((bit = *blkid % sizeof(size_t)) == 0)
+ return __ntapi_blt_acquire(blitter,blkid);
+
+ for (n=0,mask=(uintptr_t)-1; n<bit; n++)
+ mask ^= ((size_t)1 << n);
+
+ i = *blkid / (8*sizeof(size_t));
+
+ for (n=0; blitter->info.blocks_avail && (n < blitter->params.round_trips); n++) {
+ if (!(at_bsf(&bit,(mask & blitter->bitmap[i]))))
+ break;
+
+ switch (__blt_bitbite(blitter,bit,i)) {
+ case NT_STATUS_SUCCESS:
+ *blkid = bit + (i * 8 * sizeof(size_t));
+ return NT_STATUS_SUCCESS;
+
+ case NT_STATUS_DEVICE_BUSY:
+ return NT_STATUS_DEVICE_BUSY;
+
+ default:
+ break;
+ }
+ }
+
+ *blkid = ++i * 8 * sizeof(size_t);
+ return __blt_acquire(blitter,blkid);
+}
+
+
+int32_t __fastcall __ntapi_blt_possess(
+ __in nt_blitter * blitter,
+ __out intptr_t * blkid)
+{
+ int bit;
+ size_t byte;
+ uintptr_t test;
+ uintptr_t mask;
+
+ bit = *blkid % (8*sizeof(size_t));
+ byte = *blkid / (8*sizeof(size_t));
+
+ mask = ((uintptr_t)1 << bit);
+ test = at_locked_and(
+ (intptr_t *)&blitter->bitmap[byte],
+ ~mask);
+
+ if (test & mask) {
+ at_locked_dec(&blitter->info.blocks_avail);
+ at_locked_inc(&blitter->info.blocks_used);
+ }
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+int32_t __fastcall __ntapi_blt_acquire(
+ __in nt_blitter * blitter,
+ __out intptr_t * blkid)
+{
+ *blkid = 0;
+ return __blt_acquire(blitter,blkid);
+}
+
+
+int32_t __fastcall __ntapi_blt_release(
+ __in nt_blitter * blitter,
+ __out intptr_t blkid)
+{
+ size_t i;
+ unsigned int idx;
+ uintptr_t bit;
+
+ i = blkid / (8 * sizeof(uintptr_t));
+ idx = blkid % (8 * sizeof(uintptr_t));
+ bit = ((uintptr_t)1 << idx);
+
+ at_locked_or((intptr_t *)&blitter->bitmap[i],bit);
+ at_locked_dec(&blitter->info.blocks_used);
+ at_locked_inc(&blitter->info.blocks_avail);
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+void * __fastcall __ntapi_blt_get(
+ __in const nt_blitter * blitter,
+ __in intptr_t block_id)
+{
+ size_t * addr = (size_t *)blitter->info.region_addr;
+ addr += block_id;
+ return addr;
+}
+
+
+void __fastcall __ntapi_blt_set(
+ __in const nt_blitter * blitter,
+ __in intptr_t block_id,
+ __in void * val)
+{
+ size_t * addr = (size_t *)blitter->info.region_addr;
+ addr += block_id;
+ *addr = (size_t)val;
+ return;
+}
diff --git a/src/blitter/ntapi_blt_free.c b/src/blitter/ntapi_blt_free.c
new file mode 100644
index 0000000..a5956b1
--- /dev/null
+++ b/src/blitter/ntapi_blt_free.c
@@ -0,0 +1,48 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_blitter.h>
+#include <ntapi/nt_sync.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_blitter.h"
+#include "ntapi_impl.h"
+
+int32_t __fastcall __ntapi_blt_free(nt_blitter * blt_ctx)
+{
+ int32_t status;
+ void * region_addr;
+ size_t region_size;
+
+ /* validation */
+ if (!blt_ctx) return NT_STATUS_INVALID_PARAMETER;
+
+ /* free blt block */
+ region_addr = blt_ctx->info.region_addr;
+ region_size = blt_ctx->info.region_size;
+
+ if (region_size && !blt_ctx->params.region) {
+ status = __ntapi->zw_free_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ ®ion_addr,
+ ®ion_size,
+ NT_MEM_RELEASE);
+
+ if (status) return status;
+ }
+
+ /* free blt control block */
+ region_addr = blt_ctx->addr;
+ region_size = blt_ctx->size;
+
+ status = __ntapi->zw_free_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ ®ion_addr,
+ ®ion_size,
+ NT_MEM_RELEASE);
+
+ return status;
+}
diff --git a/src/daemon/ntapi_dsr_init.c b/src/daemon/ntapi_dsr_init.c
new file mode 100644
index 0000000..889de6b
--- /dev/null
+++ b/src/daemon/ntapi_dsr_init.c
@@ -0,0 +1,189 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_thread.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_daemon.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+static void __stdcall __ntapi_dsr_once(nt_daemon_params * params);
+
+int32_t __stdcall __ntapi_dsr_init(nt_daemon_params * params)
+{
+ int32_t status;
+
+ nt_thread_params tparams;
+ nt_large_integer timeout;
+
+ /* port_keys */
+ if (params->flags & NT_DSR_INIT_GENERATE_KEYS)
+ if ((status = __ntapi->tt_port_generate_keys(params->port_keys)))
+ return status;
+
+ /* port_name_keys */
+ if (params->flags & NT_DSR_INIT_FORMAT_KEYS)
+ __ntapi->tt_port_format_keys(
+ params->port_keys,
+ params->port_name_keys);
+
+ /* 'daemon-is-ready' event */
+ if (!params->hevent_daemon_ready) {
+ if ((status = __ntapi->tt_create_private_event(
+ ¶ms->hevent_daemon_ready,
+ NT_NOTIFICATION_EVENT,
+ NT_EVENT_NOT_SIGNALED)))
+ return status;
+
+ if (params->pevent_daemon_ready)
+ *(params->pevent_daemon_ready) = params->hevent_daemon_ready;
+ }
+
+ /* 'internal-client-is-ready' event */
+ if (!params->hevent_internal_client_ready) {
+ if ((status = __ntapi->tt_create_inheritable_event(
+ ¶ms->hevent_internal_client_ready,
+ NT_NOTIFICATION_EVENT,
+ NT_EVENT_NOT_SIGNALED)))
+ return status;
+
+ if (params->pevent_internal_client_ready)
+ *(params->pevent_internal_client_ready) = params->hevent_internal_client_ready;
+ }
+
+ /* daemon dedicated thread: general parameters */
+ __ntapi->tt_aligned_block_memset(
+ &tparams,0,sizeof(tparams));
+
+ tparams.start = (nt_thread_start_routine *)__ntapi_dsr_start;
+ tparams.arg = params;
+
+ /* daemon dedicated thread: stack parameters (optional) */
+ tparams.stack_size_commit = params->stack_size_commit;
+ tparams.stack_size_reserve = params->stack_size_reserve;
+ tparams.stack_info = params->stack_info;
+
+ /* daemon dedicated thread: create */
+ status = __ntapi->tt_create_local_thread(&tparams);
+ params->hthread_daemon_loop = tparams.hthread;
+ if (status) return status;
+
+ /* daemon dedicated thread: actual stack size */
+ params->stack_size_commit = tparams.stack_size_commit;
+ params->stack_size_reserve = tparams.stack_size_reserve;
+
+
+ /* establish internal connection */
+ __ntapi->tt_aligned_block_memset(
+ &tparams,0,sizeof(tparams));
+
+ tparams.start = (nt_thread_start_routine *)__ntapi_dsr_internal_client_connect;
+ tparams.arg = params;
+
+ status = __ntapi->tt_create_local_thread(&tparams);
+ params->hthread_internal_client = tparams.hthread;
+ if (status) return status;
+
+ /* wait until the internal connection had been established */
+ timeout.quad = NT_DSR_INIT_MAX_WAIT;
+
+ status = __ntapi->zw_wait_for_single_object(
+ params->hevent_internal_client_ready,
+ 0,
+ &timeout);
+
+ if (params->flags & NT_DSR_INIT_CLOSE_EVENTS) {
+ __ntapi->zw_close(params->hevent_daemon_ready);
+ __ntapi->zw_close(params->hevent_internal_client_ready);
+ }
+
+ return status;
+}
+
+
+/* __ntapi_dsr_start executes in the daemon's dedicated thread */
+int32_t __stdcall __ntapi_dsr_start(nt_daemon_params * params)
+{
+ __ntapi_dsr_once(params);
+ __ntapi_dsr_create_port(params);
+ __ntapi_dsr_connect_internal_client(params);
+ params->daemon_loop_routine(params->daemon_loop_context);
+
+ /* (no return) */
+ return NT_STATUS_INTERNAL_ERROR;
+}
+
+/* __ntapi_dsr_once executes in the daemon's dedicated thread */
+static void __stdcall __ntapi_dsr_once(nt_daemon_params * params)
+{
+ int32_t status;
+
+ if (!params->daemon_once_routine)
+ return;
+
+ if ((status = params->daemon_once_routine(params->daemon_loop_context))) {
+ params->exit_code_daemon_start = status;
+ __ntapi->zw_terminate_thread(NT_CURRENT_THREAD_HANDLE,status);
+ }
+}
+
+/* __ntapi_dsr_create_port executes in the daemon's dedicated thread */
+int32_t __stdcall __ntapi_dsr_create_port(nt_daemon_params * params)
+{
+ int32_t * pstatus;
+ nt_object_attributes oa;
+ nt_security_quality_of_service sqos;
+ nt_unicode_string server_name;
+
+ pstatus = ¶ms->exit_code_daemon_start;
+
+ /* init server_name */
+ server_name.strlen = (uint16_t)__ntapi->tt_string_null_offset_short((const int16_t *)params->port_name);
+ server_name.maxlen = 0;
+ server_name.buffer = (uint16_t *)params->port_name;
+
+ /* init security structure */
+ sqos.length = sizeof(sqos);
+ sqos.impersonation_level = NT_SECURITY_IMPERSONATION;
+ sqos.context_tracking_mode = NT_SECURITY_TRACKING_DYNAMIC;
+ sqos.effective_only = 1;
+
+ /* init the port's object attributes */
+ oa.len = sizeof(oa);
+ oa.root_dir = (void *)0;
+ oa.obj_name = &server_name;
+ oa.obj_attr = 0;
+ oa.sec_desc = (nt_security_descriptor *)0;
+ oa.sec_qos = &sqos;
+
+ /* create the port */
+ *pstatus = __ntapi->zw_create_port(
+ ¶ms->hport_daemon,
+ &oa,0,(uint32_t)params->port_msg_size,
+ 0);
+
+ if (*pstatus != NT_STATUS_SUCCESS)
+ __ntapi->zw_terminate_thread(
+ NT_CURRENT_THREAD_HANDLE,
+ *pstatus);
+
+ /* return port info */
+ if (params->pport_daemon)
+ *(params->pport_daemon) = params->hport_daemon;
+
+ /* signal the daemon-is-ready event */
+ *pstatus = __ntapi->zw_set_event(
+ params->hevent_daemon_ready,
+ (int32_t *)0);
+
+ if (*pstatus != NT_STATUS_SUCCESS)
+ __ntapi->zw_terminate_thread(
+ NT_CURRENT_THREAD_HANDLE,
+ *pstatus);
+
+ return *pstatus;
+}
diff --git a/src/daemon/ntapi_dsr_internal_connection.c b/src/daemon/ntapi_dsr_internal_connection.c
new file mode 100644
index 0000000..7726b3f
--- /dev/null
+++ b/src/daemon/ntapi_dsr_internal_connection.c
@@ -0,0 +1,142 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_thread.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_daemon.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+/* __ntapi_dsr_connect_internal_client executes in the daemon's dedicated thread */
+int32_t __stdcall __ntapi_dsr_connect_internal_client(nt_daemon_params * params)
+{
+ int32_t * pstatus;
+
+ intptr_t port_id;
+ nt_port_message port_msg;
+ nt_large_integer timeout;
+ void * _hport_client;
+
+ pstatus = ¶ms->exit_code_daemon_start;
+
+ /* timeout-enabled first connection */
+ timeout.quad = NT_DSR_INIT_MAX_WAIT;
+
+ *pstatus = __ntapi->zw_reply_wait_receive_port_ex(
+ params->hport_daemon,
+ &port_id,
+ (nt_port_message *)0,
+ (nt_port_message *)&port_msg,
+ &timeout);
+
+ if (*pstatus != NT_STATUS_SUCCESS)
+ __ntapi->zw_terminate_thread(
+ NT_CURRENT_THREAD_HANDLE,
+ *pstatus);
+
+ /* the internal client must be first */
+ if (port_msg.client_id.process_id != pe_get_current_process_id())
+ __ntapi->zw_terminate_thread(
+ NT_CURRENT_THREAD_HANDLE,
+ NT_STATUS_PORT_CONNECTION_REFUSED);
+
+ /* accept connection request */
+ *pstatus = __ntapi->zw_accept_connect_port(
+ &_hport_client,
+ port_msg.client_id.process_id,
+ (nt_port_message *)&port_msg,
+ NT_LPC_ACCEPT_CONNECTION,
+ (nt_port_section_write *)0,
+ (nt_port_section_read *)0);
+
+ if (*pstatus != NT_STATUS_SUCCESS)
+ __ntapi->zw_terminate_thread(
+ NT_CURRENT_THREAD_HANDLE,
+ *pstatus);
+
+ /* finalize connection */
+ *pstatus = __ntapi->zw_complete_connect_port(_hport_client);
+
+ if (*pstatus != NT_STATUS_SUCCESS)
+ __ntapi->zw_terminate_thread(
+ NT_CURRENT_THREAD_HANDLE,
+ *pstatus);
+
+ return *pstatus;
+}
+
+
+/* __ntapi_dsr_internal_client_connect executes in its own temporary thread */
+int32_t __stdcall __ntapi_dsr_internal_client_connect(nt_daemon_params * params)
+{
+ int32_t * pstatus;
+
+ nt_unicode_string server_name;
+ nt_object_attributes oa;
+ nt_security_quality_of_service sqos;
+ nt_large_integer timeout;
+
+ pstatus = ¶ms->exit_code_internal_client;
+
+ /* init server_name */
+ server_name.strlen = (uint16_t)__ntapi->tt_string_null_offset_short((const int16_t *)params->port_name);
+ server_name.maxlen = 0;
+ server_name.buffer = (uint16_t *)params->port_name;
+
+ /* init security structure */
+ sqos.length = sizeof(sqos);
+ sqos.impersonation_level = NT_SECURITY_IMPERSONATION;
+ sqos.context_tracking_mode = NT_SECURITY_TRACKING_DYNAMIC;
+ sqos.effective_only = 1;
+
+ /* init the port's object attributes */
+ oa.len = sizeof(oa);
+ oa.root_dir = (void *)0;
+ oa.obj_name = &server_name;
+ oa.obj_attr = 0;
+ oa.sec_desc = (nt_security_descriptor *)0;
+ oa.sec_qos = &sqos;
+
+ /* wait for the server to be ready */
+ timeout.quad = NT_DSR_INIT_MAX_WAIT;
+
+ if ((*pstatus = __ntapi->zw_wait_for_single_object(
+ params->hevent_daemon_ready,
+ 0,&timeout)))
+ __ntapi->zw_terminate_thread(
+ NT_CURRENT_THREAD_HANDLE,
+ *pstatus);
+
+ /* establish internal connection */
+ *pstatus = __ntapi->zw_connect_port(
+ ¶ms->hport_internal_client,
+ &server_name,
+ &sqos,
+ 0,0,0,0,0);
+
+ if (*pstatus != NT_STATUS_SUCCESS)
+ __ntapi->zw_terminate_thread(
+ NT_CURRENT_THREAD_HANDLE,
+ *pstatus);
+
+ /* return port info */
+ if (params->pport_internal_client)
+ *(params->pport_internal_client) = params->hport_internal_client;
+
+ /* signal the 'internal-client-is-ready' event */
+ *pstatus = __ntapi->zw_set_event(
+ params->hevent_internal_client_ready,
+ 0);
+
+ /* exit the task-specific thread */
+ __ntapi->zw_terminate_thread(
+ NT_CURRENT_THREAD_HANDLE,
+ *pstatus);
+
+ /* (no return) */
+ return NT_STATUS_INTERNAL_ERROR;
+}
diff --git a/src/fs/ntapi_tt_get_file_handle_type.c b/src/fs/ntapi_tt_get_file_handle_type.c
new file mode 100644
index 0000000..e1175a5
--- /dev/null
+++ b/src/fs/ntapi_tt_get_file_handle_type.c
@@ -0,0 +1,83 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <ntapi/ntapi.h>
+#include <ntapi/nt_file.h>
+#include "ntapi_impl.h"
+
+typedef int __stdcall winapi_get_console_mode(void * handle, uint32_t * mode);
+
+int32_t __stdcall __ntapi_tt_get_file_handle_type(
+ __in void * handle,
+ __out int32_t * type)
+{
+ int32_t status;
+ uint32_t info;
+ nt_iosb iosb;
+ nt_fsssi fsssi;
+ nt_file_directory_information fdi;
+ nt_file_pipe_information fpi;
+ nt_object_basic_information obi;
+
+ void * hkernel32;
+ char str_get_con_mode[32] = "GetConsoleMode";
+ winapi_get_console_mode * pfn_get_con_mode;
+
+ /* validation */
+ if (!handle) return NT_STATUS_INVALID_HANDLE;
+
+ /* file-system directory? */
+ if (!(status = __ntapi->zw_query_information_file(
+ handle,
+ &iosb,&fdi,sizeof(fdi),
+ NT_FILE_DIRECTORY_INFORMATION))) {
+ *type = NT_FILE_TYPE_DIRECTORY;
+ return 0;
+ }
+
+ /* file-system file? */
+ if (!(status = __ntapi->zw_query_volume_information_file(
+ handle,
+ &iosb,&fsssi,sizeof(fsssi),
+ NT_FILE_FS_SECTOR_SIZE_INFORMATION))) {
+ *type = NT_FILE_TYPE_FILE;
+ return 0;
+ }
+
+ /* pipe? */
+ if (!(status = __ntapi->zw_query_information_file(
+ handle,
+ &iosb,&fpi,sizeof(fpi),
+ NT_FILE_PIPE_INFORMATION))) {
+ *type = NT_FILE_TYPE_PIPE;
+ return 0;
+ }
+
+
+ /* csrss? */
+ if (!(hkernel32 = pe_get_kernel32_module_handle()))
+ return NT_STATUS_DLL_INIT_FAILED;
+ else if (!(pfn_get_con_mode = (winapi_get_console_mode *)pe_get_procedure_address(
+ hkernel32,str_get_con_mode)))
+ return NT_STATUS_DLL_INIT_FAILED;
+
+
+ /* (console functions return non-zero on success) */
+ if ((pfn_get_con_mode(handle,&info))) {
+ *type = NT_FILE_TYPE_CSRSS;
+ return 0;
+ }
+
+ /* invalid handle? */
+ if ((status = __ntapi->zw_query_object(
+ handle,NT_OBJECT_BASIC_INFORMATION,
+ &obi,sizeof(obi),&info)))
+ return status;
+
+ /* unknown object */
+ *type = NT_FILE_TYPE_UNKNOWN;
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/fs/ntapi_tt_istat.c b/src/fs/ntapi_tt_istat.c
new file mode 100644
index 0000000..bd2029d
--- /dev/null
+++ b/src/fs/ntapi_tt_istat.c
@@ -0,0 +1,155 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <ntapi/ntapi.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_fsctl.h>
+#include <ntapi/nt_mount.h>
+#include <ntapi/nt_istat.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tt_istat(
+ __in void * hfile,
+ __in void * hroot __optional,
+ __in nt_unicode_string * path,
+ __out nt_istat * istat,
+ __out uintptr_t * buffer,
+ __in uint32_t buffer_size,
+ __in uint32_t open_options,
+ __in uint32_t flags)
+{
+ int32_t status;
+
+ nt_oa oa;
+ nt_iosb iosb;
+ nt_unicode_string * sdev;
+ uint32_t hash;
+ wchar16_t * wch;
+ wchar16_t * wch_mark;
+
+ /* validaton */
+ if (!hfile && !path)
+ return NT_STATUS_INVALID_HANDLE;
+
+ /* hfile */
+ if (!hfile) {
+ /* oa */
+ oa.len = sizeof(nt_oa);
+ oa.root_dir = hroot;
+ oa.obj_name = path;
+ oa.obj_attr = 0;
+ oa.sec_desc = 0;
+ oa.sec_qos = 0;
+
+ /* open file/folder */
+ status = __ntapi->zw_open_file(
+ &hfile,
+ NT_SEC_SYNCHRONIZE | NT_FILE_READ_ATTRIBUTES | NT_FILE_READ_ACCESS,
+ &oa,
+ &iosb,
+ NT_FILE_SHARE_READ | NT_FILE_SHARE_WRITE,
+ open_options | NT_FILE_SYNCHRONOUS_IO_ALERT);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ istat->flags_out = NT_STAT_NEW_HANDLE;
+ }
+
+ istat->hfile = hfile;
+ istat->flags_in = flags;
+
+ /* file index number */
+ status = __ntapi->zw_query_information_file(
+ hfile,
+ &iosb,
+ &istat->fii,
+ sizeof(istat->fii),
+ NT_FILE_INTERNAL_INFORMATION);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ /* attributes & reparse tag information */
+ status = __ntapi->zw_query_information_file(
+ hfile,
+ &iosb,
+ &istat->ftagi,
+ sizeof(istat->ftagi),
+ NT_FILE_ATTRIBUTE_TAG_INFORMATION);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ /* TODO: consolidate with statfs */
+ /* system-unique device name */
+ iosb.info = 0;
+ status = __ntapi->zw_query_object(
+ hfile,
+ NT_OBJECT_NAME_INFORMATION,
+ buffer,
+ buffer_size,
+ (uint32_t *)&iosb.info);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ sdev = (nt_unicode_string *)buffer;
+
+ if (sdev->strlen < __DEVICE_PATH_PREFIX_LEN)
+ return NT_STATUS_INVALID_HANDLE;
+
+ hash = __ntapi->tt_buffer_crc32(
+ 0,
+ sdev->buffer,
+ __DEVICE_PATH_PREFIX_LEN);
+
+ if (hash != __DEVICE_PATH_PREFIX_HASH)
+ return NT_STATUS_INVALID_HANDLE;
+
+ wch_mark = sdev->buffer + __DEVICE_PATH_PREFIX_LEN/sizeof(wchar16_t);
+ wch = wch_mark;
+ while (*wch != '\\') wch++;
+ istat->dev_name_strlen = (uint16_t)((wch - sdev->buffer) * sizeof(uint16_t));
+
+ istat->dev_name_hash = __ntapi->tt_buffer_crc32(
+ hash,
+ wch_mark,
+ (uintptr_t)wch - (uintptr_t)wch_mark);
+
+ return status;
+}
+
+
+int32_t __stdcall __ntapi_tt_validate_fs_handle(
+ __in void * hfile,
+ __in uint32_t dev_name_hash,
+ __in nt_fii fii,
+ __out uintptr_t * buffer,
+ __in uint32_t buffer_size)
+{
+ int32_t status;
+ nt_istat istat;
+
+ status = __ntapi->tt_istat(
+ hfile,
+ (void *)0,
+ (nt_unicode_string *)0,
+ &istat,
+ buffer,
+ buffer_size,
+ 0,
+ NT_ISTAT_DEFAULT);
+
+ if (status) return status;
+
+ if (istat.fii.index_number.quad != fii.index_number.quad)
+ return NT_STATUS_CONTEXT_MISMATCH;
+ else if (istat.dev_name_hash != dev_name_hash)
+ return NT_STATUS_CONTEXT_MISMATCH;
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/fs/ntapi_tt_mount.c b/src/fs/ntapi_tt_mount.c
new file mode 100644
index 0000000..1718750
--- /dev/null
+++ b/src/fs/ntapi_tt_mount.c
@@ -0,0 +1,358 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_mount.h>
+#include <ntapi/nt_atomic.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+typedef enum __dos_drive_handle_type {
+ __DOS_DRIVE_DEVICE_HANDLE,
+ __DOS_DRIVE_ROOT_HANDLE
+} _dos_drive_handle_type;
+
+typedef struct __dos_name_buffer {
+ wchar16_t global_prefix[4];
+ wchar16_t dos_letter;
+ wchar16_t colon;
+ wchar16_t root;
+ wchar16_t null_termination;
+} _dos_name_buffer;
+
+
+static int32_t __stdcall __tt_connect_to_mount_point_manager(void)
+{
+ int32_t status;
+
+ void * hdev;
+ void * hdev_prev;
+ nt_oa oa;
+ nt_iosb iosb;
+ nt_unicode_string dev_name;
+ uint16_t dev_name_buffer[] = {
+ '\\','?','?','\\',
+ 'M','o','u','n','t',
+ 'P','o','i','n','t',
+ 'M','a','n','a','g','e','r',0};
+
+ dev_name.strlen = sizeof(wchar16_t) * (4+5+5+7);
+ dev_name.maxlen = 0;
+ dev_name.buffer = dev_name_buffer;
+
+ oa.len = sizeof(nt_oa);
+ oa.root_dir = (void *)0;
+ oa.obj_name = &dev_name;
+ oa.obj_attr = NT_OBJ_CASE_INSENSITIVE;
+ oa.sec_desc = (nt_sd *)0;
+ oa.sec_qos = (nt_sqos *)0;
+
+ status = __ntapi->zw_create_file(
+ &hdev,
+ NT_SEC_SYNCHRONIZE | NT_FILE_READ_ATTRIBUTES,
+ &oa,
+ &iosb,
+ 0,
+ NT_FILE_ATTRIBUTE_NORMAL,
+ NT_FILE_SHARE_READ | NT_FILE_SHARE_WRITE,
+ NT_FILE_OPEN,
+ NT_FILE_NON_DIRECTORY_FILE | NT_FILE_SYNCHRONOUS_IO_NONALERT,
+ (void *)0,
+ 0);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ hdev_prev = (void *)at_locked_cas(
+ (intptr_t *)&__ntapi_internals()->hdev_mount_point_mgr,
+ 0,(intptr_t)hdev);
+
+ if (hdev_prev)
+ __ntapi->zw_close(hdev);
+
+ return status;
+}
+
+
+static int32_t __stdcall __tt_get_dos_drive_device_or_root_handle(
+ __out void ** hdrive,
+ __in wchar16_t * drive_letter,
+ __in _dos_drive_handle_type handle_type)
+{
+ #define __common_mode (NT_FILE_SYNCHRONOUS_IO_ALERT)
+ #define __common_access (NT_SEC_SYNCHRONIZE \
+ | NT_FILE_READ_ATTRIBUTES)
+
+ int32_t status;
+
+ nt_oa oa;
+ nt_iosb iosb;
+ uint32_t open_flags;
+ uint32_t access_flags;
+ nt_unicode_string dos_name;
+ _dos_name_buffer dos_name_buffer = {
+ {'\\','?','?','\\'},
+ '_',':',0,0};
+
+ if (!hdrive || !drive_letter)
+ return NT_STATUS_INVALID_PARAMETER;
+
+ if ((*drive_letter>='A') && (*drive_letter<='Z'))
+ dos_name_buffer.dos_letter = *drive_letter;
+ else if ((*drive_letter>='a') && (*drive_letter<='z'))
+ dos_name_buffer.dos_letter = *drive_letter + 'A' - 'a';
+ else
+ return NT_STATUS_INVALID_PARAMETER_2;
+
+ dos_name.strlen = ((size_t)(&((_dos_name_buffer *)0)->root));
+ dos_name.maxlen = 0;
+ dos_name.buffer = &(dos_name_buffer.global_prefix[0]);
+
+ switch (handle_type) {
+ case __DOS_DRIVE_DEVICE_HANDLE:
+ open_flags = __common_mode;
+ access_flags = __common_access;
+ break;
+
+ case __DOS_DRIVE_ROOT_HANDLE:
+ open_flags = __common_mode | NT_FILE_DIRECTORY_FILE;
+ access_flags = __common_access | NT_FILE_READ_ACCESS;
+ dos_name_buffer.root = '\\';
+ dos_name.strlen += sizeof(wchar16_t);
+ break;
+ default:
+ open_flags = 0;
+ access_flags = 0;
+ break;
+ }
+
+ oa.len = sizeof(nt_oa);
+ oa.root_dir = (void *)0;
+ oa.obj_name = &dos_name;
+ oa.obj_attr = NT_OBJ_INHERIT;
+ oa.sec_desc = (nt_sd *)0;
+ oa.sec_qos = (nt_sqos *)0;
+
+ status = __ntapi->zw_open_file(
+ hdrive,
+ access_flags,
+ &oa,
+ &iosb,
+ NT_FILE_SHARE_READ | NT_FILE_SHARE_WRITE,
+ open_flags);
+
+ return status;
+}
+
+
+int32_t __stdcall __ntapi_tt_get_dos_drive_device_handle(
+ __out void ** hdevice,
+ __in wchar16_t * drive_letter)
+{
+ return __tt_get_dos_drive_device_or_root_handle(
+ hdevice,
+ drive_letter,
+ __DOS_DRIVE_DEVICE_HANDLE);
+}
+
+
+int32_t __stdcall __ntapi_tt_get_dos_drive_root_handle(
+ __out void ** hroot,
+ __in wchar16_t * drive_letter)
+{
+ return __tt_get_dos_drive_device_or_root_handle(
+ hroot,
+ drive_letter,
+ __DOS_DRIVE_ROOT_HANDLE);
+}
+
+
+
+int32_t __stdcall __ntapi_tt_get_dos_drive_device_name(
+ __in void * hdevice __optional,
+ __in wchar16_t * drive_letter __optional,
+ __out nt_mount_dev_name * buffer,
+ __in uint32_t buffer_size)
+{
+ int32_t status;
+ nt_iosb iosb;
+
+ if (!hdevice && (status = __tt_get_dos_drive_device_or_root_handle(
+ &hdevice,
+ drive_letter,
+ __DOS_DRIVE_DEVICE_HANDLE)))
+ return status;
+
+ return __ntapi->zw_device_io_control_file(
+ hdevice,
+ (void *)0,
+ (nt_io_apc_routine *)0,
+ (void *)0,
+ &iosb,
+ NT_IOCTL_MOUNTDEV_QUERY_DEVICE_NAME,
+ (void *)0,
+ 0,
+ buffer,
+ buffer_size);
+}
+
+
+int32_t __stdcall __ntapi_tt_get_dos_drive_mount_points(
+ __in void * hdevice __optional,
+ __in wchar16_t * drive_letter __optional,
+ __in nt_mount_dev_name * dev_name __optional,
+ __out void * buffer,
+ __in uint32_t buffer_size)
+{
+ int32_t status;
+ nt_iosb iosb;
+ wchar16_t dev_name_buffer[64];
+ nt_mount_point_param * dev_mount_point;
+ nt_mount_points * dev_mount_points;
+ uintptr_t addr;
+
+ if (!dev_name) {
+ dev_name = (nt_mount_dev_name *)&dev_name_buffer;
+ if ((status = __ntapi_tt_get_dos_drive_device_name(
+ hdevice,
+ drive_letter,
+ dev_name,
+ sizeof(dev_name_buffer))))
+ return status;
+ }
+
+ if (buffer_size < sizeof(nt_mount_mgr_mount_point) \
+ + sizeof(nt_mount_dev_name) \
+ + sizeof(dev_name->name_length))
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ dev_mount_point = (nt_mount_point_param *)buffer;
+ dev_mount_point->symlink_name_offset = 0;
+ dev_mount_point->symlink_name_length = 0;
+ dev_mount_point->unique_id_offset = 0;
+ dev_mount_point->unique_id_length = 0;
+ dev_mount_point->device_name_offset = ((size_t)(&((nt_mount_point_param *)0)->device_name));
+ dev_mount_point->device_name_length = dev_name->name_length;
+ dev_mount_point->mount_points_offset = 0;
+
+ __ntapi->tt_memcpy_utf16(
+ dev_mount_point->device_name,
+ dev_name->name,
+ dev_name->name_length);
+
+ addr = (uintptr_t)(dev_mount_point->device_name) + dev_name->name_length;
+ addr += sizeof(uintptr_t) - 1;
+ addr /= sizeof(uintptr_t);
+ addr *= sizeof(uintptr_t);
+ dev_mount_points = (nt_mount_points *)addr;
+
+
+ if (!__ntapi_internals()->hdev_mount_point_mgr)
+ status = __tt_connect_to_mount_point_manager();
+
+ if (!__ntapi_internals()->hdev_mount_point_mgr)
+ return status;
+
+
+ status = __ntapi->zw_device_io_control_file(
+ __ntapi_internals()->hdev_mount_point_mgr,
+ (void *)0,
+ (nt_io_apc_routine *)0,
+ (void *)0,
+ &iosb,
+ NT_IOCTL_MOUNTMGR_QUERY_POINTS,
+ dev_mount_point,
+ (uint32_t)(uintptr_t)&(((nt_mount_point_param *)0)->device_name) + dev_name->name_length,
+ dev_mount_points,
+ (uint32_t)((uintptr_t)buffer + buffer_size - addr));
+
+ dev_mount_point->mount_points_offset = (uint16_t)((uintptr_t)addr - (uintptr_t)buffer);
+
+ return status;
+}
+
+
+int32_t __stdcall __ntapi_tt_dev_mount_points_to_statfs(
+ __in nt_mount_points * mount_points,
+ __in_out nt_statfs * statfs)
+{
+ int32_t status;
+ uint32_t hash;
+ uint32_t i;
+
+ nt_mount_mgr_mount_point * mount_point;
+ char * symlink;
+
+ mount_point = mount_points->mount_points;
+ statfs->nt_drive_letter = 0;
+
+
+ for (i = 0; i < mount_points->number; i++, mount_point++) {
+ symlink = (char *)mount_points + mount_point->symlink_name_offset;
+
+ /* both prefixes of interest happen to be of the same length */
+ hash = __ntapi->tt_buffer_crc32(
+ 0, symlink, __DOS_DEVICES_PREFIX_LEN);
+
+ if (hash == __DOS_DEVICES_PREFIX_HASH)
+ statfs->nt_drive_letter = ((nt_dos_devices_name *)(symlink))->letter;
+ else if (hash == __VOLUME_PATH_PREFIX_HASH) {
+ status = __ntapi_tt_utf16_string_to_guid(
+ (nt_guid_str_utf16 *)(symlink \
+ + __VOLUME_PATH_PREFIX_LEN \
+ - sizeof(wchar16_t)),
+ &statfs->nt_volume_guid);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+ }
+ }
+
+ return 0;
+}
+
+
+int32_t __stdcall __ntapi_tt_get_dos_drive_letter_from_device(
+ __in void * hdevice __optional,
+ __out wchar16_t * drive_letter,
+ __in nt_mount_dev_name * dev_name __optional,
+ __out void * buffer,
+ __in uint32_t buffer_size)
+{
+ int32_t status;
+ wchar16_t dev_name_buffer[128];
+ nt_statfs statfs;
+ uint32_t offset;
+ nt_mount_points * mnt_points;
+
+ if (!dev_name) {
+ dev_name = (nt_mount_dev_name *)&dev_name_buffer;
+ status = __ntapi_tt_get_dos_drive_device_name(
+ hdevice,
+ (wchar16_t *)0,
+ dev_name,
+ sizeof(dev_name_buffer));
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+ }
+
+
+ offset = ((nt_mount_point_param *)buffer)->mount_points_offset;
+ mnt_points = (nt_mount_points *)((uintptr_t)buffer + offset);
+
+ status = __ntapi_tt_dev_mount_points_to_statfs(
+ mnt_points,
+ &statfs);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ *drive_letter = statfs.nt_drive_letter;
+
+ return status;
+}
diff --git a/src/fs/ntapi_tt_open_logical_parent_directory.c b/src/fs/ntapi_tt_open_logical_parent_directory.c
new file mode 100644
index 0000000..c20d05b
--- /dev/null
+++ b/src/fs/ntapi_tt_open_logical_parent_directory.c
@@ -0,0 +1,21 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <ntapi/ntapi.h>
+#include <ntapi/nt_file.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tt_open_logical_parent_directory(
+ __out void ** hparent,
+ __in void * hdir,
+ __out uintptr_t * buffer,
+ __in uint32_t buffer_size,
+ __in uint32_t desired_access,
+ __in uint32_t open_options,
+ __out int32_t * type)
+{
+ return NT_STATUS_MORE_PROCESSING_REQUIRED;
+}
diff --git a/src/fs/ntapi_tt_open_physical_parent_directory.c b/src/fs/ntapi_tt_open_physical_parent_directory.c
new file mode 100644
index 0000000..68d282b
--- /dev/null
+++ b/src/fs/ntapi_tt_open_physical_parent_directory.c
@@ -0,0 +1,69 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <ntapi/ntapi.h>
+#include <ntapi/nt_file.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tt_open_physical_parent_directory(
+ __out void ** hparent,
+ __in void * hdir,
+ __out uintptr_t * buffer,
+ __in uint32_t buffer_size,
+ __in uint32_t desired_access,
+ __in uint32_t open_options,
+ __out int32_t * type)
+{
+ int32_t status;
+ nt_oa oa;
+ nt_iosb iosb;
+ wchar16_t * wch;
+ nt_unicode_string * path;
+ uint32_t len;
+
+ path = (nt_unicode_string *)buffer;
+
+ if ((status = __ntapi->zw_query_object(
+ hdir,
+ NT_OBJECT_NAME_INFORMATION,
+ path,
+ buffer_size,
+ &len)))
+ return status;
+ else if (len == sizeof(nt_unicode_string))
+ return NT_STATUS_BAD_FILE_TYPE;
+
+ wch = path->buffer + (path->strlen / sizeof(uint16_t));
+ while ((--wch >= path->buffer) && (*wch != '\\'));
+
+ if (wch == path->buffer )
+ return NT_STATUS_MORE_PROCESSING_REQUIRED;
+
+ path->strlen = sizeof(uint16_t) * (uint16_t)(wch-path->buffer);
+ path->maxlen = 0;
+
+ /* oa */
+ oa.len = sizeof(nt_oa);
+ oa.root_dir = 0;
+ oa.obj_name = path;
+ oa.obj_attr = 0;
+ oa.sec_desc = 0;
+ oa.sec_qos = 0;
+
+ /* default access */
+ desired_access = desired_access
+ ? desired_access
+ : NT_SEC_SYNCHRONIZE | NT_FILE_READ_ATTRIBUTES | NT_FILE_READ_ACCESS;
+
+ /* open parent directory */
+ return __ntapi->zw_open_file(
+ hparent,
+ desired_access,
+ &oa,
+ &iosb,
+ NT_FILE_SHARE_READ | NT_FILE_SHARE_WRITE,
+ open_options | NT_FILE_DIRECTORY_FILE);
+}
diff --git a/src/fs/ntapi_tt_stat.c b/src/fs/ntapi_tt_stat.c
new file mode 100644
index 0000000..51cc55a
--- /dev/null
+++ b/src/fs/ntapi_tt_stat.c
@@ -0,0 +1,129 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <ntapi/ntapi.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_fsctl.h>
+#include <ntapi/nt_mount.h>
+#include <ntapi/nt_stat.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tt_stat(
+ __in void * hfile,
+ __in void * hroot __optional,
+ __in nt_unicode_string * path,
+ __out nt_stat * stat,
+ __out uintptr_t * buffer,
+ __in uint32_t buffer_size,
+ __in uint32_t open_options,
+ __in uint32_t flags)
+{
+ int32_t status;
+ nt_oa oa;
+ nt_iosb iosb;
+ nt_unicode_string * sdev;
+ nt_fai * fai;
+
+ /* validation */
+ if (!hfile && !path)
+ return NT_STATUS_INVALID_HANDLE;
+
+ /* hfile */
+ if (!hfile) {
+ /* oa */
+ oa.len = sizeof(nt_oa);
+ oa.root_dir = hroot;
+ oa.obj_name = path;
+ oa.obj_attr = 0;
+ oa.sec_desc = 0;
+ oa.sec_qos = 0;
+
+ /* open file/folder */
+ status = __ntapi->zw_open_file(
+ &hfile,
+ NT_SEC_SYNCHRONIZE | NT_FILE_READ_ATTRIBUTES | NT_FILE_READ_ACCESS,
+ &oa,
+ &iosb,
+ NT_FILE_SHARE_READ | NT_FILE_SHARE_WRITE,
+ open_options | NT_FILE_SYNCHRONOUS_IO_ALERT);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ stat->flags_out = NT_STAT_NEW_HANDLE;
+ }
+
+ stat->hfile = hfile;
+ stat->flags_in = flags;
+
+ /* system-unique device name */
+ status = __ntapi->zw_query_information_file(
+ hfile,
+ &iosb,
+ buffer,
+ buffer_size,
+ NT_FILE_ALL_INFORMATION);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ /* copy file info minus name */
+ fai = (nt_fai *)buffer;
+ __ntapi->tt_aligned_block_memcpy(
+ (uintptr_t *)stat,
+ (uintptr_t *)fai,
+ ((size_t)(&((nt_fai *)0)->name_info)));
+
+ /* record the file name length, but do not hash */
+ stat->file_name_length = fai->name_info.file_name_length;
+ stat->file_name_hash = 0;
+
+
+ /* file system size information */
+ status = __ntapi->zw_query_volume_information_file(
+ hfile,
+ &iosb,
+ &(stat->fssi),
+ sizeof(stat->fssi),
+ NT_FILE_FS_SIZE_INFORMATION);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ /* system-unique device name (simpler than statfs) */
+ iosb.info = 0;
+ status = __ntapi->zw_query_object(
+ hfile,
+ NT_OBJECT_NAME_INFORMATION,
+ buffer,
+ buffer_size,
+ (uint32_t *)&iosb.info);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ sdev = (nt_unicode_string *)buffer;
+ stat->dev_name_strlen = sdev->strlen - (uint16_t)stat->file_name_length;
+
+ stat->dev_name_hash = __ntapi->tt_buffer_crc32(
+ 0,
+ sdev->buffer,
+ stat->dev_name_strlen);
+
+ if (flags & NT_STAT_DEV_NAME_COPY) {
+ if (stat->dev_name_maxlen < sdev->strlen)
+ /* does not justify failure */
+ *stat->dev_name = 0;
+ else
+ __ntapi->tt_memcpy_utf16(
+ (wchar16_t *)stat->dev_name,
+ (wchar16_t *)sdev->buffer,
+ stat->dev_name_strlen);
+ } else
+ *stat->dev_name = 0;
+
+ return status;
+}
diff --git a/src/fs/ntapi_tt_statfs.c b/src/fs/ntapi_tt_statfs.c
new file mode 100644
index 0000000..114cc8e
--- /dev/null
+++ b/src/fs/ntapi_tt_statfs.c
@@ -0,0 +1,225 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <ntapi/ntapi.h>
+#include <ntapi/nt_fsctl.h>
+#include <ntapi/nt_mount.h>
+#include <ntapi/nt_statfs.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tt_statfs(
+ __in void * hfile,
+ __in void * hroot __optional,
+ __in nt_unicode_string * path,
+ __out nt_statfs * statfs,
+ __out uintptr_t * buffer,
+ __in uint32_t buffer_size,
+ __in uint32_t flags)
+{
+ int32_t status;
+ nt_oa oa;
+ nt_iosb iosb;
+ nt_unicode_string * sdev;
+ uint32_t hash;
+ wchar16_t * wch;
+ wchar16_t * wch_mark;
+ uint32_t offset;
+ void * mnt_points_buffer;
+ nt_mount_points * mnt_points;
+ nt_fsai * fsai;
+ nt_fsfsi * fsfsi;
+ uint32_t * fsid;
+ uint64_t * pguid;
+
+ /* validation */
+ if (!hfile && !path)
+ return NT_STATUS_INVALID_HANDLE;
+
+ /* hfile */
+ if (!hfile) {
+ /* oa */
+ oa.len = sizeof(nt_oa);
+ oa.root_dir = hroot;
+ oa.obj_name = path;
+ oa.obj_attr = 0;
+ oa.sec_desc = 0;
+ oa.sec_qos = 0;
+
+ /* open file/folder */
+ status = __ntapi->zw_open_file(
+ &hfile,
+ NT_SEC_SYNCHRONIZE | NT_FILE_READ_ATTRIBUTES | NT_FILE_READ_ACCESS,
+ &oa,
+ &iosb,
+ NT_FILE_SHARE_READ | NT_FILE_SHARE_WRITE,
+ NT_FILE_SYNCHRONOUS_IO_ALERT);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ statfs->flags_out = NT_STATFS_NEW_HANDLE;
+ }
+
+ statfs->hfile = hfile;
+ statfs->flags_in = flags;
+
+ /* maximum component length, file system type */
+ status = __ntapi->zw_query_volume_information_file(
+ hfile,
+ &iosb,
+ buffer,
+ buffer_size,
+ NT_FILE_FS_ATTRIBUTE_INFORMATION);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ fsai = (nt_fsai *)buffer;
+ statfs->f_type = 0;
+ statfs->f_namelen = fsai->maximum_component_name_length;
+ statfs->nt_fstype_hash = __ntapi->tt_buffer_crc32(
+ 0,
+ &fsai->file_system_name,
+ fsai->file_system_name_length);
+
+ /* max files per volume */
+ switch (statfs->nt_fstype_hash) {
+ case NT_FS_TYPE_HPFS_NAME_HASH:
+ case NT_FS_TYPE_NTFS_NAME_HASH:
+ case NT_FS_TYPE_SMB_NAME_HASH:
+ case NT_FS_TYPE_UDF_NAME_HASH:
+ statfs->f_files = 0xFFFFFFFF;
+ break;
+
+ case NT_FS_TYPE_FAT16_NAME_HASH:
+ statfs->f_files = 0x10000;
+ break;
+
+ case NT_FS_TYPE_FAT32_NAME_HASH:
+ statfs->f_files = 0x400000;
+ break;
+
+ default:
+ /* pretend there is no limitation */
+ statfs->f_files = (-1);
+ break;
+ }
+
+ /* number of free file records on volume */
+ /* (skip, yet indicate that the volume is not empty) */
+ statfs->f_ffree = (size_t)statfs->f_files >> 4 << 3;
+
+ /* file system size information */
+ status = __ntapi->zw_query_volume_information_file(
+ hfile,
+ &iosb,
+ buffer,
+ buffer_size,
+ NT_FILE_FS_FULL_SIZE_INFORMATION);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ fsfsi = (nt_fsfsi *)buffer;
+ statfs->f_blocks = fsfsi->total_allocation_units.quad;
+ statfs->f_bfree = fsfsi->actual_available_allocation_units.quad;
+ statfs->f_bavail = fsfsi->caller_available_allocation_units.quad;
+ statfs->f_bsize = fsfsi->sectors_per_allocation_unit * fsfsi->bytes_per_sector;
+ statfs->f_frsize = fsfsi->bytes_per_sector;
+
+ /* TODO: consolidate with istat */
+ /* system-unique device name */
+ iosb.info = 0;
+ status = __ntapi->zw_query_object(
+ hfile,
+ NT_OBJECT_NAME_INFORMATION,
+ buffer,
+ buffer_size,
+ (uint32_t *)&iosb.info);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ sdev = (nt_unicode_string *)buffer;
+
+ if (sdev->strlen < __DEVICE_PATH_PREFIX_LEN)
+ return NT_STATUS_INVALID_HANDLE;
+
+ hash = __ntapi->tt_buffer_crc32(
+ 0,
+ sdev->buffer,
+ __DEVICE_PATH_PREFIX_LEN);
+
+ if (hash != __DEVICE_PATH_PREFIX_HASH)
+ return NT_STATUS_INVALID_HANDLE;
+
+ wch_mark = sdev->buffer + __DEVICE_PATH_PREFIX_LEN/sizeof(wchar16_t);
+ wch = wch_mark;
+ while (*wch != '\\') wch++;
+ statfs->dev_name_strlen = (uint16_t)((wch - sdev->buffer) * sizeof(uint16_t));
+ statfs->record_name_strlen = sdev->strlen - statfs->dev_name_strlen;
+
+ statfs->dev_name_hash = __ntapi->tt_buffer_crc32(
+ hash,wch_mark,
+ sizeof(wchar16_t) * (wch - wch_mark));
+
+ /* copy device name (optional, no failure) */
+ if (flags & NT_STATFS_DEV_NAME_COPY) {
+ if (statfs->dev_name_maxlen < sdev->strlen)
+ *statfs->dev_name = 0;
+ else
+ __ntapi->tt_memcpy_utf16(
+ (wchar16_t *)statfs->dev_name,
+ (wchar16_t *)sdev->buffer,
+ sdev->strlen);
+ } else
+ *statfs->dev_name = 0;
+
+ /* f_fsid: hash of the system-unique device name */
+ /* (never use the volume serial number) */
+ fsid = (uint32_t *)&(statfs->f_fsid);
+ fsid[0] = statfs->dev_name_hash;
+ fsid[1] = 0;
+
+ /* f_flags, nt_attr, nt_control_flags (todo?) */
+ statfs->f_flags = 0;
+ statfs->nt_attr = 0;
+ statfs->nt_control_flags = 0;
+ statfs->nt_padding = 0;
+
+ if (!(flags & NT_STATFS_VOLUME_GUID)) {
+ statfs->nt_drive_letter = 0;
+ pguid = (uint64_t *)&(statfs->nt_volume_guid);
+ *pguid = 0; *(++pguid) = 0;
+ return NT_STATUS_SUCCESS;
+ }
+
+ /* dos device letter and volume guid */
+ wch = (wchar16_t *)sdev->buffer;
+ mnt_points_buffer = (void *)((uintptr_t)wch + statfs->dev_name_strlen);
+
+ *(--wch) = statfs->dev_name_strlen;
+ offset = sizeof(nt_unicode_string) + statfs->dev_name_strlen;
+
+ status = __ntapi->tt_get_dos_drive_mount_points(
+ (void *)0,
+ (wchar16_t *)0,
+ (nt_mount_dev_name *)wch,
+ mnt_points_buffer,
+ buffer_size - offset);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ offset = ((nt_mount_point_param *)mnt_points_buffer)->mount_points_offset;
+ mnt_points = (nt_mount_points *)((uintptr_t)mnt_points_buffer + offset);
+
+ status = __ntapi->tt_dev_mount_points_to_statfs(
+ mnt_points,
+ statfs);
+
+ return status;
+}
diff --git a/src/guid/ntapi_tt_guid.c b/src/guid/ntapi_tt_guid.c
new file mode 100644
index 0000000..07cd938
--- /dev/null
+++ b/src/guid/ntapi_tt_guid.c
@@ -0,0 +1,182 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_time.h>
+#include <ntapi/nt_guid.h>
+#include "ntapi_impl.h"
+
+
+void __fastcall __ntapi_tt_guid_copy(
+ __out nt_guid * pguid_dst,
+ __in const nt_guid * pguid_src)
+{
+ uint64_t * dst;
+ uint64_t * src;
+
+ dst = (uint64_t *)pguid_dst;
+ src = (uint64_t *)pguid_src;
+
+ *dst = *src;
+ src++; dst++;
+ *dst = *src;
+}
+
+
+void __fastcall __ntapi_tt_guid_to_utf16_string(
+ __in const nt_guid * guid,
+ __out nt_guid_str_utf16 * guid_str)
+{
+ uint16_t key;
+ wchar16_t * wch;
+
+ wch = &(guid_str->group5[0]);
+
+ __ntapi_tt_uint32_to_hex_utf16(
+ guid->data1,
+ &guid_str->group1[0]);
+
+ __ntapi_tt_uint16_to_hex_utf16(
+ guid->data2,
+ &guid_str->group2[0]);
+
+ __ntapi_tt_uint16_to_hex_utf16(
+ guid->data3,
+ &guid_str->group3[0]);
+
+ key = guid->data4[0] * 0x100 + guid->data4[1];
+
+ __ntapi_tt_uint16_to_hex_utf16(
+ key,
+ &guid_str->group4[0]);
+
+ key = guid->data4[2] * 0x100 + guid->data4[3];
+
+ __ntapi_tt_uint16_to_hex_utf16(
+ key,
+ &guid_str->group5[0]);
+
+ key = guid->data4[4] * 0x100 + guid->data4[5];
+
+ __ntapi_tt_uint16_to_hex_utf16(
+ key,
+ &(wch[4]));
+
+ key = guid->data4[6] * 0x100 + guid->data4[7];
+
+ __ntapi_tt_uint16_to_hex_utf16(
+ key,
+ &(wch[8]));
+
+ guid_str->lbrace = '{';
+ guid_str->rbrace = '}';
+ guid_str->dash1 = '-';
+ guid_str->dash2 = '-';
+ guid_str->dash3 = '-';
+ guid_str->dash4 = '-';
+
+ return;
+}
+
+
+int32_t __fastcall __ntapi_tt_guid_compare(
+ __in const nt_guid * pguid_dst,
+ __in const nt_guid * pguid_src)
+{
+ uint64_t * dst;
+ uint64_t * src;
+
+ dst = (uint64_t *)pguid_dst;
+ src = (uint64_t *)pguid_src;
+
+ if ((*dst != *src) || (*(++dst) != *(++src)))
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+int32_t __fastcall __ntapi_tt_utf16_string_to_guid(
+ __out nt_guid_str_utf16 * guid_str,
+ __in nt_guid * guid)
+{
+ int32_t status;
+ wchar16_t * wch;
+ uint16_t key;
+
+ if ((guid_str->lbrace != '{')
+ || (guid_str->rbrace != '}')
+ || (guid_str->dash1 != '-')
+ || (guid_str->dash2 != '-')
+ || (guid_str->dash3 != '-')
+ || (guid_str->dash4 != '-'))
+ return NT_STATUS_INVALID_PARAMETER;
+
+ wch = &(guid_str->group5[0]);
+
+ status = __ntapi_tt_hex_utf16_to_uint32(
+ guid_str->group1,
+ &guid->data1);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ status = __ntapi_tt_hex_utf16_to_uint16(
+ guid_str->group2,
+ &guid->data2);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ status = __ntapi_tt_hex_utf16_to_uint16(
+ guid_str->group3,
+ &guid->data3);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ status = __ntapi_tt_hex_utf16_to_uint16(
+ guid_str->group4,
+ &key);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ guid->data4[0] = key / 0x100;
+ guid->data4[1] = key % 0x100;
+
+ status = __ntapi_tt_hex_utf16_to_uint16(
+ &(wch[0]),
+ &key);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ guid->data4[2] = key / 0x100;
+ guid->data4[3] = key % 0x100;
+
+ status = __ntapi_tt_hex_utf16_to_uint16(
+ &(wch[4]),
+ &key);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ guid->data4[4] = key / 0x100;
+ guid->data4[5] = key % 0x100;
+
+ status = __ntapi_tt_hex_utf16_to_uint16(
+ &(wch[8]),
+ &key);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ guid->data4[6] = key / 0x100;
+ guid->data4[7] = key % 0x100;
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/hash/ntapi_tt_crc32.c b/src/hash/ntapi_tt_crc32.c
new file mode 100644
index 0000000..7ce25d3
--- /dev/null
+++ b/src/hash/ntapi_tt_crc32.c
@@ -0,0 +1,50 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_crc32.h>
+
+static const uint32_t crc32_table[256] = NTAPI_CRC32_TABLE;
+
+uint32_t __ntapi_tt_buffer_crc32(
+ uint32_t prev_hash,
+ const void * buffer,
+ size_t size)
+{
+ unsigned char * ch;
+ uint32_t crc32;
+
+ crc32 = prev_hash ^ 0xFFFFFFFF;
+ ch = (unsigned char *)buffer;
+
+ for (; size; size--,ch++)
+ crc32 = (crc32 >> 8) ^ crc32_table[(crc32 ^ *ch) & 0xFF];
+
+ return (crc32 ^ 0xFFFFFFFF);
+}
+
+
+uint32_t __cdecl __ntapi_tt_mbstr_crc32(const void * str)
+{
+ uint32_t crc32;
+ unsigned char * ch;
+
+ crc32 = 0 ^ 0xFFFFFFFF;
+ ch = (unsigned char *)str;
+
+ while (*ch) {
+ crc32 = (crc32 >> 8) ^ crc32_table[(crc32 ^ *ch) & 0xFF];
+ ch++;
+ }
+
+ return (crc32 ^ 0xFFFFFFFF);
+}
+
+
+const uint32_t * __cdecl __ntapi_tt_crc32_table(void)
+{
+ return crc32_table;
+}
diff --git a/src/hash/ntapi_tt_populate_hashed_import_table.c b/src/hash/ntapi_tt_populate_hashed_import_table.c
new file mode 100644
index 0000000..a36ed2f
--- /dev/null
+++ b/src/hash/ntapi_tt_populate_hashed_import_table.c
@@ -0,0 +1,95 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <pemagine/pemagine.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_crc32.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+struct callback_ctx {
+ void * import_table;
+ ntapi_hashed_symbol * hash_table;
+ uint32_t hash_table_array_size;
+};
+
+
+static int __process_exported_symbol(
+ const void * base,
+ struct pe_export_hdr * exp_hdr,
+ struct pe_export_sym * exp_item,
+ enum pe_callback_reason reason,
+ void * context)
+{
+ uint32_t hash_value;
+ struct callback_ctx * ctx;
+ ntapi_hashed_symbol * hashed_symbol;
+ uintptr_t * fnptr;
+
+ /* binary search variables */
+ uint32_t lower;
+ uint32_t upper;
+ uint32_t idx;
+
+ if (reason != PE_CALLBACK_REASON_ITEM)
+ return 1;
+
+ ctx = (struct callback_ctx *)context;
+ hash_value = __ntapi_tt_mbstr_crc32(exp_item->name);
+
+ /* zero-based array, binary search, idx < upper is guaranteed */
+ lower = 0;
+ upper = ctx->hash_table_array_size;
+
+ /* binary search */
+ while (lower < upper) {
+ idx = (lower + upper) / 2;
+ hashed_symbol = (ntapi_hashed_symbol *)
+ ((uintptr_t)ctx->hash_table
+ + idx * sizeof(ntapi_hashed_symbol));
+
+ if (hash_value == hashed_symbol->crc32_hash) {
+ fnptr = (uintptr_t *)(
+ (uintptr_t)ctx->import_table
+ + (sizeof(uintptr_t)
+ * hashed_symbol->ordinal));
+ *fnptr = (uintptr_t)exp_item->addr;
+ return 1;
+ }
+
+ else {
+ if (hash_value > hashed_symbol->crc32_hash)
+ lower = idx + 1;
+ else
+ upper = idx;
+ }
+ }
+
+ return 1;
+}
+
+int32_t __cdecl __ntapi_tt_populate_hashed_import_table(
+ __in void * image_base,
+ __in void * import_table,
+ __in ntapi_hashed_symbol * hash_table,
+ __in uint32_t hash_table_array_size)
+{
+ struct pe_export_sym exp_item;
+ struct callback_ctx ctx;
+
+ ctx.import_table = import_table;
+ ctx.hash_table = hash_table;
+ ctx.hash_table_array_size = hash_table_array_size;
+
+ pe_enum_image_exports(
+ image_base,
+ &__process_exported_symbol,
+ &exp_item,
+ &ctx);
+
+ return 0;
+}
diff --git a/src/internal/ntapi.c b/src/internal/ntapi.c
new file mode 100644
index 0000000..2340c47
--- /dev/null
+++ b/src/internal/ntapi.c
@@ -0,0 +1,411 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <pemagine/pemagine.h>
+
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_crc32.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_sysinfo.h>
+#include <ntapi/nt_memory.h>
+#include <ntapi/nt_section.h>
+#include <ntapi/nt_thread.h>
+#include <ntapi/nt_process.h>
+#include <ntapi/nt_job.h>
+#include <ntapi/nt_token.h>
+#include <ntapi/nt_sync.h>
+#include <ntapi/nt_time.h>
+#include <ntapi/nt_profiling.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_device.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_registry.h>
+#include <ntapi/nt_security.h>
+#include <ntapi/nt_pnp.h>
+#include <ntapi/nt_exception.h>
+#include <ntapi/nt_locale.h>
+#include <ntapi/nt_uuid.h>
+#include <ntapi/nt_atom.h>
+#include <ntapi/nt_os.h>
+#include <ntapi/nt_ldr.h>
+#include <ntapi/nt_string.h>
+#include <ntapi/nt_guid.h>
+#include <ntapi/nt_argv.h>
+#include <ntapi/nt_blitter.h>
+#include <ntapi/nt_unicode.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/nt_mount.h>
+#include <ntapi/nt_istat.h>
+#include <ntapi/nt_stat.h>
+#include <ntapi/nt_statfs.h>
+#include <ntapi/nt_daemon.h>
+#include <ntapi/nt_tty.h>
+#include <ntapi/nt_vmount.h>
+#include <ntapi/nt_hash.h>
+#include <ntapi/nt_debug.h>
+#include <ntapi/nt_atomic.h>
+#include <ntapi/ntapi.h>
+
+#include "ntapi_impl.h"
+#include "ntapi_hash_table.h"
+
+/* simplified once mechanism for free-standing applications */
+typedef int32_t __fastcall __ntapi_init_fn(ntapi_vtbl ** pvtbl);
+
+static __ntapi_init_fn __ntapi_init_once;
+static __ntapi_init_fn __ntapi_init_pending;
+static __ntapi_init_fn __ntapi_init_completed;
+
+static intptr_t __ntapi_init_idx = 0;
+static __ntapi_init_fn * __ntapi_init_vtbl[3] = {
+ __ntapi_init_once,
+ __ntapi_init_pending,
+ __ntapi_init_completed};
+
+/* accessor */
+ntapi_vtbl ___ntapi = {0};
+ntapi_vtbl ___ntapi_shadow = {0};
+
+/* .bss */
+static __ntapi_img_sec_bss __ntapi_img_bss;
+
+/* .rdata */
+static union __ntapi_img_rdata __ntapi_rdata = {{
+ {__NTAPI_HASH_TABLE}, /* __ntapi_import_table */
+ 0, /* __ntapi */
+ {{0}}, /* __session_name */
+ 0}}; /* __internals */
+
+#define internals __ntapi_rdata.img_sec_data.__internals
+#define import_table __ntapi_rdata.img_sec_data.__ntapi_import_table
+
+
+static int32_t __fastcall __ntapi_init_once(ntapi_vtbl ** pvtbl)
+{
+ int32_t status;
+ void * hntdll;
+ size_t block_size;
+ ntapi_zw_allocate_virtual_memory * pfn_zw_allocate_virtual_memory;
+ char fname_allocate_virtual_memory[] =
+ "ZwAllocateVirtualMemory";
+ /* once */
+ at_locked_inc(&__ntapi_init_idx);
+
+ /* pvtbl */
+ if (!(pvtbl))
+ return NT_STATUS_INVALID_PARAMETER;
+ else
+ *pvtbl = (ntapi_vtbl *)0;
+
+ /* ntdll */
+ if (!(hntdll = pe_get_ntdll_module_handle()))
+ return NT_STATUS_DLL_INIT_FAILED;
+
+ pfn_zw_allocate_virtual_memory = (ntapi_zw_allocate_virtual_memory *)
+ pe_get_procedure_address(
+ hntdll,
+ fname_allocate_virtual_memory);
+
+ if (!pfn_zw_allocate_virtual_memory)
+ return NT_STATUS_DLL_INIT_FAILED;
+
+ /* ntapi_internals: alloc */
+ block_size = sizeof(ntapi_internals);
+ status = pfn_zw_allocate_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ (void **)&internals,
+ 0,
+ &block_size,
+ NT_MEM_COMMIT,
+ NT_PAGE_READWRITE);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ /* hashed import table */
+ __ntapi_tt_populate_hashed_import_table(
+ pe_get_ntdll_module_handle(),
+ __ntapi,
+ import_table,
+ __NT_IMPORTED_SYMBOLS_ARRAY_SIZE);
+
+ /* alternate implementation */
+ __ntapi->rtl_init_unicode_string = __ntapi_tt_init_unicode_string_from_utf16;
+
+ /* extension functions */
+ /* nt_object.h */
+ __ntapi->tt_create_keyed_object_directory = __ntapi_tt_create_keyed_object_directory;
+ __ntapi->tt_open_keyed_object_directory = __ntapi_tt_open_keyed_object_directory;
+ __ntapi->tt_create_keyed_object_directory_entry = __ntapi_tt_create_keyed_object_directory_entry;
+
+ /* nt_crc32.h */
+ __ntapi->tt_buffer_crc32 = __ntapi_tt_buffer_crc32;
+ __ntapi->tt_mbstr_crc32 = __ntapi_tt_mbstr_crc32;
+ __ntapi->tt_crc32_table = __ntapi_tt_crc32_table;
+
+ /* nt_file.h */
+ __ntapi->tt_get_file_handle_type = __ntapi_tt_get_file_handle_type;
+ __ntapi->tt_open_logical_parent_directory = __ntapi_tt_open_logical_parent_directory;
+ __ntapi->tt_open_physical_parent_directory = __ntapi_tt_open_physical_parent_directory;
+
+ /* nt_ldr.h */
+ __ntapi->ldr_load_system_dll = __ntapi_ldr_load_system_dll;
+ __ntapi->ldr_create_state_snapshot = __ntapi_ldr_create_state_snapshot;
+ __ntapi->ldr_revert_state_to_snapshot = __ntapi_ldr_revert_state_to_snapshot;
+
+ /* nt_string.h */
+ __ntapi->tt_string_null_offset_multibyte = __ntapi_tt_string_null_offset_multibyte;
+ __ntapi->tt_string_null_offset_short = __ntapi_tt_string_null_offset_short;
+ __ntapi->tt_string_null_offset_dword = __ntapi_tt_string_null_offset_dword;
+ __ntapi->tt_string_null_offset_qword = __ntapi_tt_string_null_offset_qword;
+ __ntapi->tt_string_null_offset_ptrsize = __ntapi_tt_string_null_offset_ptrsize;
+ __ntapi->strlen = __ntapi_tt_string_null_offset_multibyte;
+ __ntapi->wcslen = __ntapi_wcslen;
+ __ntapi->tt_aligned_block_memset = __ntapi_tt_aligned_block_memset;
+ __ntapi->tt_aligned_block_memcpy = __ntapi_tt_aligned_block_memcpy;
+ __ntapi->tt_memcpy_utf16 = __ntapi_tt_memcpy_utf16;
+ __ntapi->tt_aligned_memcpy_utf16 = __ntapi_tt_aligned_memcpy_utf16;
+ __ntapi->tt_generic_memset = __ntapi_tt_generic_memset;
+ __ntapi->tt_generic_memcpy = __ntapi_tt_generic_memcpy;
+ __ntapi->tt_uint16_to_hex_utf16 = __ntapi_tt_uint16_to_hex_utf16;
+ __ntapi->tt_uint32_to_hex_utf16 = __ntapi_tt_uint32_to_hex_utf16;
+ __ntapi->tt_uint64_to_hex_utf16 = __ntapi_tt_uint64_to_hex_utf16;
+ __ntapi->tt_uintptr_to_hex_utf16 = __ntapi_tt_uintptr_to_hex_utf16;
+ __ntapi->tt_hex_utf16_to_uint16 = __ntapi_tt_hex_utf16_to_uint16;
+ __ntapi->tt_hex_utf16_to_uint32 = __ntapi_tt_hex_utf16_to_uint32;
+ __ntapi->tt_hex_utf16_to_uint64 = __ntapi_tt_hex_utf16_to_uint64;
+ __ntapi->tt_hex_utf16_to_uintptr = __ntapi_tt_hex_utf16_to_uintptr;
+ __ntapi->tt_init_unicode_string_from_utf16 = __ntapi_tt_init_unicode_string_from_utf16;
+ __ntapi->tt_uint16_to_hex_utf8 = __ntapi_tt_uint16_to_hex_utf8;
+ __ntapi->tt_uint32_to_hex_utf8 = __ntapi_tt_uint32_to_hex_utf8;
+ __ntapi->tt_uint64_to_hex_utf8 = __ntapi_tt_uint64_to_hex_utf8;
+ __ntapi->tt_uintptr_to_hex_utf8 = __ntapi_tt_uintptr_to_hex_utf8;
+
+ /* nt_guid.h */
+ __ntapi->tt_guid_copy = __ntapi_tt_guid_copy;
+ __ntapi->tt_guid_compare = __ntapi_tt_guid_compare;
+ __ntapi->tt_guid_to_utf16_string = __ntapi_tt_guid_to_utf16_string;
+ __ntapi->tt_utf16_string_to_guid = __ntapi_tt_utf16_string_to_guid;
+
+ /* nt_sysinfo.h */
+ __ntapi->tt_get_system_directory_native_path = __ntapi_tt_get_system_directory_native_path;
+ __ntapi->tt_get_system_directory_dos_path = __ntapi_tt_get_system_directory_dos_path;
+ __ntapi->tt_get_system_directory_handle = __ntapi_tt_get_system_directory_handle;
+ __ntapi->tt_get_system_info_snapshot = __ntapi_tt_get_system_info_snapshot;
+
+ /* nt_thread.h */
+ __ntapi->tt_create_local_thread = __ntapi_tt_create_local_thread;
+ __ntapi->tt_create_remote_thread = __ntapi_tt_create_remote_thread;
+ __ntapi->tt_create_thread = __ntapi_tt_create_thread;
+
+ /* nt_process.h */
+ __ntapi->tt_create_remote_process_params = __ntapi_tt_create_remote_process_params;
+ __ntapi->tt_get_runtime_data = __ntapi_tt_get_runtime_data;
+ __ntapi->tt_init_runtime_data = __ntapi_tt_init_runtime_data;
+ __ntapi->tt_update_runtime_data = __ntapi_tt_update_runtime_data;
+ __ntapi->tt_exec_map_image_as_data = __ntapi_tt_exec_map_image_as_data;
+ __ntapi->tt_exec_unmap_image = __ntapi_tt_exec_unmap_image;
+
+ /* nt_section.h */
+ __ntapi->tt_get_section_name = __ntapi_tt_get_section_name;
+
+ /* nt_sync.h */
+ __ntapi->tt_create_inheritable_event = __ntapi_tt_create_inheritable_event;
+ __ntapi->tt_create_private_event = __ntapi_tt_create_private_event;
+ __ntapi->tt_wait_for_dummy_event = __ntapi_tt_wait_for_dummy_event;
+ __ntapi->tt_sync_block_init = __ntapi_tt_sync_block_init;
+ __ntapi->tt_sync_block_lock = __ntapi_tt_sync_block_lock;
+ __ntapi->tt_sync_block_server_lock = __ntapi_tt_sync_block_server_lock;
+ __ntapi->tt_sync_block_unlock = __ntapi_tt_sync_block_unlock;
+ __ntapi->tt_sync_block_invalidate = __ntapi_tt_sync_block_invalidate;
+
+ /* nt_port.h */
+ __ntapi->csr_port_handle = __ntapi_csr_port_handle;
+ __ntapi->tt_port_guid_from_type = __ntapi_tt_port_guid_from_type;
+ __ntapi->tt_port_type_from_guid = __ntapi_tt_port_type_from_guid;
+ __ntapi->tt_port_generate_keys = __ntapi_tt_port_generate_keys;
+ __ntapi->tt_port_format_keys = __ntapi_tt_port_format_keys;
+ __ntapi->tt_port_name_from_attributes = __ntapi_tt_port_name_from_attributes;
+
+ /* nt_argv.h */
+ __ntapi->tt_get_cmd_line_utf16 = __ntapi_tt_get_cmd_line_utf16;
+ __ntapi->tt_get_peb_env_block_utf16 = __ntapi_tt_get_peb_env_block_utf16;
+ __ntapi->tt_parse_cmd_line_args_utf16 = __ntapi_tt_parse_cmd_line_args_utf16;
+ __ntapi->tt_get_argv_envp_utf8 = __ntapi_tt_get_argv_envp_utf8;
+ __ntapi->tt_get_argv_envp_utf16 = __ntapi_tt_get_argv_envp_utf16;
+ __ntapi->tt_get_env_var_meta_utf16 = __ntapi_tt_get_env_var_meta_utf16;
+ __ntapi->tt_get_short_option_meta_utf16 = __ntapi_tt_get_short_option_meta_utf16;
+ __ntapi->tt_get_long_option_meta_utf16 = __ntapi_tt_get_long_option_meta_utf16;
+ __ntapi->tt_array_copy_utf16 = __ntapi_tt_array_copy_utf16;
+ __ntapi->tt_array_copy_utf8 = __ntapi_tt_array_copy_utf8;
+ __ntapi->tt_array_convert_utf8_to_utf16 = __ntapi_tt_array_convert_utf8_to_utf16;
+ __ntapi->tt_array_convert_utf16_to_utf8 = __ntapi_tt_array_convert_utf16_to_utf8;
+
+ /* nt_blitter.h */
+ __ntapi->blt_alloc = __ntapi_blt_alloc;
+ __ntapi->blt_free = __ntapi_blt_free;
+ __ntapi->blt_acquire = __ntapi_blt_acquire;
+ __ntapi->blt_obtain = __ntapi_blt_obtain;
+ __ntapi->blt_possess = __ntapi_blt_possess;
+ __ntapi->blt_release = __ntapi_blt_release;
+ __ntapi->blt_get = __ntapi_blt_get;
+ __ntapi->blt_set = __ntapi_blt_set;
+
+ /* nt_unicode.h */
+ __ntapi->uc_validate_unicode_stream_utf8 = __ntapi_uc_validate_unicode_stream_utf8;
+ __ntapi->uc_validate_unicode_stream_utf16 = __ntapi_uc_validate_unicode_stream_utf16;
+ __ntapi->uc_get_code_point_byte_count_utf8 = __ntapi_uc_get_code_point_byte_count_utf8;
+ __ntapi->uc_get_code_point_byte_count_utf16 = __ntapi_uc_get_code_point_byte_count_utf16;
+ __ntapi->uc_convert_unicode_stream_utf8_to_utf16 = __ntapi_uc_convert_unicode_stream_utf8_to_utf16;
+ __ntapi->uc_convert_unicode_stream_utf8_to_utf32 = __ntapi_uc_convert_unicode_stream_utf8_to_utf32;
+ __ntapi->uc_convert_unicode_stream_utf16_to_utf8 = __ntapi_uc_convert_unicode_stream_utf16_to_utf8;
+ __ntapi->uc_convert_unicode_stream_utf16_to_utf32 = __ntapi_uc_convert_unicode_stream_utf16_to_utf32;
+
+ /* nt_daemon.h */
+ __ntapi->dsr_init = __ntapi_dsr_init;
+ __ntapi->dsr_start = __ntapi_dsr_start;
+ __ntapi->dsr_create_port = __ntapi_dsr_create_port;
+ __ntapi->dsr_connect_internal_client = __ntapi_dsr_connect_internal_client;
+ __ntapi->dsr_internal_client_connect = __ntapi_dsr_internal_client_connect;
+
+ /* nt_vfd.h */
+ __ntapi->vfd_dev_name_init = __ntapi_vfd_dev_name_init;
+
+ /* nt_tty.h */
+ __ntapi->tty_create_session = __ntapi_tty_create_session;
+ __ntapi->tty_join_session = __ntapi_tty_join_session;
+ __ntapi->tty_connect = __ntapi_tty_connect;
+ __ntapi->tty_client_session_query = __ntapi_tty_client_session_query;
+ __ntapi->tty_client_session_set = __ntapi_tty_client_session_set;
+ __ntapi->tty_client_process_register = __ntapi_tty_client_process_register;
+ __ntapi->tty_query_information_server = __ntapi_tty_query_information_server;
+ __ntapi->tty_request_peer = __ntapi_tty_request_peer;
+ __ntapi->tty_vms_query = __ntapi_tty_vms_query;
+ __ntapi->tty_vms_request = __ntapi_tty_vms_request;
+ __ntapi->pty_open = __ntapi_pty_open;
+ __ntapi->pty_reopen = __ntapi_pty_reopen;
+ __ntapi->pty_close = __ntapi_pty_close;
+ __ntapi->pty_read = __ntapi_pty_read;
+ __ntapi->pty_write = __ntapi_pty_write;
+ __ntapi->pty_ioctl = __ntapi_pty_ioctl;
+ __ntapi->pty_query = __ntapi_pty_query;
+ __ntapi->pty_set = __ntapi_pty_set;
+ __ntapi->pty_cancel = __ntapi_pty_cancel;
+
+ /* nt_socket.h */
+ __ntapi->sc_listen = __ntapi_sc_listen;
+ __ntapi->sc_accept = __ntapi_sc_accept;
+ __ntapi->sc_send = __ntapi_sc_send;
+ __ntapi->sc_recv = __ntapi_sc_recv;
+ __ntapi->sc_shutdown = __ntapi_sc_shutdown;
+ __ntapi->sc_server_duplicate_socket = __ntapi_sc_server_duplicate_socket;
+ __ntapi->sc_wait = __ntapi_sc_wait;
+
+ /* nt_mount.h */
+ __ntapi->tt_get_dos_drive_device_handle = __ntapi_tt_get_dos_drive_device_handle;
+ __ntapi->tt_get_dos_drive_root_handle = __ntapi_tt_get_dos_drive_root_handle;
+ __ntapi->tt_get_dos_drive_device_name = __ntapi_tt_get_dos_drive_device_name;
+ __ntapi->tt_get_dos_drive_mount_points = __ntapi_tt_get_dos_drive_mount_points;
+ __ntapi->tt_dev_mount_points_to_statfs = __ntapi_tt_dev_mount_points_to_statfs;
+ __ntapi->tt_get_dos_drive_letter_from_device = __ntapi_tt_get_dos_drive_letter_from_device;
+
+ /* nt_istat.h */
+ __ntapi->tt_istat = __ntapi_tt_istat;
+ __ntapi->tt_validate_fs_handle = __ntapi_tt_validate_fs_handle;
+
+ /* nt_stat.h */
+ __ntapi->tt_stat = __ntapi_tt_stat;
+
+ /* nt_statfs.h */
+ __ntapi->tt_statfs = __ntapi_tt_statfs;
+
+ /* nt_vmount.h */
+ __ntapi->vms_get_node_by_dev_name = __ntapi_vms_get_node_by_dev_name;
+ __ntapi->vms_get_node_by_end_component = __ntapi_vms_get_node_by_end_component;
+ __ntapi->vms_cache_alloc = __ntapi_vms_cache_alloc;
+ __ntapi->vms_cache_free = __ntapi_vms_cache_free;
+ __ntapi->vms_client_connect = __ntapi_vms_client_connect;
+ __ntapi->vms_client_disconnect = __ntapi_vms_client_disconnect;
+ __ntapi->vms_point_attach = __ntapi_vms_point_attach;
+ __ntapi->vms_point_get_handles = __ntapi_vms_point_get_handles;
+ __ntapi->vms_ref_count_inc = __ntapi_vms_ref_count_inc;
+ __ntapi->vms_ref_count_dec = __ntapi_vms_ref_count_dec;
+ __ntapi->vms_table_query = __ntapi_vms_table_query;
+
+ /* nt_debug.h */
+ #ifdef __DEBUG
+ __ntapi->dbg_write = __dbg_write;
+ __ntapi->dbg_fn_call = __dbg_fn_call;
+ __ntapi->dbg_msg = __dbg_msg;
+ #endif
+
+
+ /* OS version dependent functions */
+ if (__ntapi->zw_create_user_process) {
+ __ntapi->tt_fork = __ntapi_tt_fork_v2;
+ __ntapi->tt_create_native_process = __ntapi_tt_create_native_process_v2;
+ __ntapi->ipc_create_pipe = __ntapi_ipc_create_pipe_v2;
+ __ntapi->sc_socket = __ntapi_sc_socket_v2;
+ __ntapi->sc_bind = __ntapi_sc_bind_v2;
+ __ntapi->sc_connect = __ntapi_sc_connect_v2;
+ __ntapi->sc_server_accept_connection = __ntapi_sc_server_accept_connection_v2;
+ __ntapi->sc_getsockname = __ntapi_sc_getsockname_v2;
+ } else {
+ __ntapi->tt_fork = __ntapi_tt_fork_v1;
+ __ntapi->tt_create_native_process = __ntapi_tt_create_native_process_v1;
+ __ntapi->ipc_create_pipe = __ntapi_ipc_create_pipe_v1;
+ __ntapi->sc_socket = __ntapi_sc_socket_v1;
+ __ntapi->sc_bind = __ntapi_sc_bind_v1;
+ __ntapi->sc_connect = __ntapi_sc_connect_v1;
+ __ntapi->sc_server_accept_connection = __ntapi_sc_server_accept_connection_v1;
+ __ntapi->sc_getsockname = __ntapi_sc_getsockname_v1;
+ }
+
+ /* internals */
+ internals->ntapi_img_sec_bss = &__ntapi_img_bss;
+ internals->subsystem = &__ntapi_rdata.img_sec_data.__session_name;
+
+ internals->tt_get_csr_port_handle_addr_by_logic = __GET_CSR_PORT_HANDLE_BY_LOGIC;
+ internals->csr_port_handle_addr = __GET_CSR_PORT_HANDLE_BY_LOGIC();
+
+ /* shadow copy for client libraries */
+ __ntapi->tt_aligned_block_memcpy(
+ (uintptr_t *)&___ntapi_shadow,
+ (uintptr_t *)&___ntapi,
+ sizeof(ntapi_vtbl));
+
+ /* done */
+ *pvtbl = &___ntapi_shadow;
+ at_locked_inc(&__ntapi_init_idx);
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+static int32_t __fastcall __ntapi_init_pending(ntapi_vtbl ** pvtbl)
+{
+ return NT_STATUS_PENDING;
+}
+
+static int32_t __fastcall __ntapi_init_completed(ntapi_vtbl ** pvtbl)
+{
+ *pvtbl = __ntapi;
+ return NT_STATUS_SUCCESS;
+};
+
+
+__ntapi_api
+int32_t __fastcall ntapi_init(ntapi_vtbl ** pvtbl)
+{
+ return __ntapi_init_vtbl[__ntapi_init_idx](pvtbl);
+}
+
+
+ntapi_internals * __cdecl __ntapi_internals(void)
+{
+ return internals;
+}
diff --git a/src/internal/ntapi_blitter.h b/src/internal/ntapi_blitter.h
new file mode 100644
index 0000000..9a285d9
--- /dev/null
+++ b/src/internal/ntapi_blitter.h
@@ -0,0 +1,27 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#ifndef ___NTAPI_BLITTER_H_
+#define ___NTAPI_BLITTER_H_
+
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_blitter.h>
+#include <ntapi/nt_sync.h>
+
+#define __NT_BLITTER_DEFAULT_LOCK_TRIES 256
+#define __NT_BLITTER_DEFAULT_ROUND_TRIPS 64
+
+typedef struct nt_blitter_context {
+ struct nt_blitter_context * addr;
+ size_t size;
+ uintptr_t ptrs;
+ nt_blitter_info info;
+ nt_blitter_params params;
+ uintptr_t * bitmap;
+ uintptr_t bits[];
+} nt_blitter;
+
+#endif
diff --git a/src/internal/ntapi_context.h b/src/internal/ntapi_context.h
new file mode 100644
index 0000000..4020158
--- /dev/null
+++ b/src/internal/ntapi_context.h
@@ -0,0 +1,55 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#ifndef ___NTAPI_CONTEXT_H_
+#define ___NTAPI_CONTEXT_H_
+
+#if defined(__X86_MODEL)
+ /* csr port handle */
+ #define __GET_CSR_PORT_HANDLE_BY_LOGIC __ntapi_tt_get_csr_port_handle_addr_by_logic_i386
+
+ /* register names */
+ #define STACK_POINTER_REGISTER uc_esp
+ #define INSTRUCTION_POINTER_REGISTER uc_eip
+ #define FAST_CALL_ARG0 uc_ecx
+ #define FAST_CALL_ARG1 uc_edx
+
+ /* thread context initialization */
+ #define __INIT_CONTEXT(context) \
+ context.uc_context_flags = NT_CONTEXT_JUST_EVERYTHING; \
+ context.uc_seg_gs = 0x00; \
+ context.uc_seg_fs = 0x3b; \
+ context.uc_seg_es = 0x23; \
+ context.uc_seg_ds = 0x23; \
+ context.uc_seg_ss = 0x23; \
+ context.uc_seg_cs = 0x1b; \
+ context.uc_eflags = 0x200
+
+#elif defined (__X86_64_MODEL)
+ /* csr port handle */
+ #define __GET_CSR_PORT_HANDLE_BY_LOGIC __ntapi_tt_get_csr_port_handle_addr_by_logic_x86_64
+
+ /* register names */
+ #define STACK_POINTER_REGISTER uc_rsp
+ #define INSTRUCTION_POINTER_REGISTER uc_rip
+ #define FAST_CALL_ARG0 uc_rcx
+ #define FAST_CALL_ARG1 uc_rdx
+
+ /* thread context initialization */
+ #define __INIT_CONTEXT(context) \
+ context.uc_context_flags= NT_CONTEXT_JUST_EVERYTHING; \
+ context.uc_seg_cs = 0x33; \
+ context.uc_seg_ds = 0x2b; \
+ context.uc_seg_es = 0x2b; \
+ context.uc_seg_fs = 0x53; \
+ context.uc_seg_gs = 0x2b; \
+ context.uc_seg_ss = 0x2b; \
+ context.uc_eflags = 0x200; \
+ context.uc_mx_csr = 0x1f80
+
+#endif
+
+#endif
diff --git a/src/internal/ntapi_debug.c b/src/internal/ntapi_debug.c
new file mode 100644
index 0000000..cb56c64
--- /dev/null
+++ b/src/internal/ntapi_debug.c
@@ -0,0 +1,170 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#ifdef __DEBUG
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+char dbg_buf[0x1000];
+
+ssize_t __cdecl __dbg_write(
+ __in void * hfile,
+ __in const void * buf,
+ __in size_t bytes)
+{
+ nt_iosb iosb;
+ int32_t status;
+
+ status = __ntapi->zw_write_file(
+ hfile,
+ (void *)0,
+ (nt_io_apc_routine *)0,
+ (void *)0,
+ &iosb,
+ (void *)buf,
+ (uint32_t)bytes,
+ (nt_large_integer *)0,
+ (uint32_t *)0);
+
+ if (status == NT_STATUS_SUCCESS)
+ return iosb.info;
+ else
+ return -1;
+}
+
+
+int32_t __cdecl __dbg_fn_call(
+ __in void * hfile __optional,
+ __in char * fn_caller_name,
+ __in void * fn_callee_addr,
+ __in uintptr_t fn_ret,
+ __in ntapi_dbg_write* pfn_dbg_write __optional,
+ __in char * source __optional,
+ __in int line __optional)
+{
+ struct pe_ldr_tbl_entry * image_meta;
+ void * image_base;
+ char * fn_name;
+ size_t bytes;
+ char dbg_buf[256];
+
+ if (!pfn_dbg_write)
+ pfn_dbg_write = __dbg_write;
+
+ image_meta = pe_get_symbol_module_info(fn_callee_addr);
+ fn_name = (char *)0;
+
+ if (image_meta)
+ image_base = image_meta->dll_base;
+ else
+ image_base = (void *)0;
+
+
+ if (image_base)
+ fn_name = pe_get_symbol_name(
+ image_base,
+ fn_callee_addr);
+
+ if (!fn_name)
+ fn_name = pe_get_import_symbol_info(
+ fn_callee_addr,
+ (void **)0,
+ (char **)0,
+ &image_meta);
+
+ if (source && fn_name)
+ bytes = __ntapi->sprintf(
+ dbg_buf,
+ "%s: (%s:%d):\n"
+ "--> %s returned 0x%08x\n\n",
+ fn_caller_name, source, line, fn_name, fn_ret);
+ else if (fn_name)
+ bytes = __ntapi->sprintf(
+ dbg_buf,
+ "%s: %s returned 0x%08x\n\n",
+ fn_caller_name, fn_name, fn_ret);
+ else if (source)
+ bytes = __ntapi->sprintf(
+ dbg_buf,
+ "%s: (%s:%d):\n"
+ "--> calling 0x%08x returned 0x%08x\n\n",
+ fn_caller_name, source, line, fn_callee_addr, fn_ret);
+ else
+ bytes = __ntapi->sprintf(
+ dbg_buf,
+ "%s: calling 0x%08x returned 0x%08x\n\n",
+ fn_caller_name, fn_callee_addr, fn_ret);
+
+ if (bytes) {
+ bytes = __ntapi->strlen(dbg_buf);
+
+ if (bytes == pfn_dbg_write(hfile,dbg_buf,bytes))
+ return NT_STATUS_SUCCESS;
+ else
+ return NT_STATUS_UNSUCCESSFUL;
+ } else
+ return NT_STATUS_UNSUCCESSFUL;
+}
+
+
+int32_t __cdecl __dbg_msg(
+ __in void * hfile __optional,
+ __in char * source __optional,
+ __in int line __optional,
+ __in char * fn_caller_name,
+ __in char * fmt,
+ __in uintptr_t arg1,
+ __in uintptr_t arg2,
+ __in uintptr_t arg3,
+ __in uintptr_t arg4,
+ __in uintptr_t arg5,
+ __in uintptr_t arg6,
+ __in ntapi_dbg_write* pfn_dbg_write __optional)
+{
+ char * buffer;
+ size_t bytes;
+
+ if (!pfn_dbg_write)
+ pfn_dbg_write = __dbg_write;
+
+ bytes = 0;
+ buffer = dbg_buf;
+
+ if (source)
+ bytes = __ntapi->sprintf(
+ buffer,
+ "%s: (%s:%d):\n--> ",
+ fn_caller_name,source,line);
+ else if (fn_caller_name)
+ bytes = __ntapi->sprintf(
+ buffer,
+ "%s: ",
+ fn_caller_name);
+ else
+ dbg_buf[0] = '\0';
+
+ if (bytes >= 0)
+ buffer += __ntapi->strlen(dbg_buf);
+ else
+ return NT_STATUS_UNSUCCESSFUL;
+
+ bytes = __ntapi->sprintf(buffer,fmt,arg1,arg2,arg3,arg4,arg5,arg6);
+
+ if (bytes) {
+ bytes = __ntapi->strlen(dbg_buf);
+
+ if (bytes == pfn_dbg_write(hfile,dbg_buf,bytes))
+ return NT_STATUS_SUCCESS;
+ else
+ return NT_STATUS_UNSUCCESSFUL;
+ } else
+ return NT_STATUS_UNSUCCESSFUL;
+}
+
+#endif
diff --git a/src/internal/ntapi_fnapi.h b/src/internal/ntapi_fnapi.h
new file mode 100644
index 0000000..4474334
--- /dev/null
+++ b/src/internal/ntapi_fnapi.h
@@ -0,0 +1,262 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#ifndef ___NTAPI_FNAPI_H_
+#define ___NTAPI_FNAPI_H_
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_hash_table.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* internal prototypes */
+typedef int32_t __stdcall ntapi_tt_create_remote_runtime_data(
+ __in void * hprocess,
+ __in_out nt_runtime_data_block * runtime_data);
+
+typedef void ** __cdecl ntapi_tt_get_csr_port_handle_addr_by_logic(void);
+
+/* nt_object.h */
+ntapi_tt_create_keyed_object_directory __ntapi_tt_create_keyed_object_directory;
+ntapi_tt_open_keyed_object_directory __ntapi_tt_open_keyed_object_directory;
+ntapi_tt_create_keyed_object_directory_entry __ntapi_tt_create_keyed_object_directory_entry;
+
+/* nt_crc32.h */
+ntapi_tt_buffer_crc32 __ntapi_tt_buffer_crc32;
+ntapi_tt_mbstr_crc32 __ntapi_tt_mbstr_crc32;
+ntapi_tt_crc32_table __ntapi_tt_crc32_table;
+
+/* nt_file.h */
+ntapi_tt_get_file_handle_type __ntapi_tt_get_file_handle_type;
+ntapi_tt_open_logical_parent_directory __ntapi_tt_open_logical_parent_directory;
+ntapi_tt_open_physical_parent_directory __ntapi_tt_open_physical_parent_directory;
+
+
+/* nt_ipc.h */
+ntapi_ipc_create_pipe __ntapi_ipc_create_pipe_v1;
+ntapi_ipc_create_pipe __ntapi_ipc_create_pipe_v2;
+
+/* nt_ldr */
+ntapi_ldr_load_system_dll __ntapi_ldr_load_system_dll;
+ntapi_ldr_create_state_snapshot __ntapi_ldr_create_state_snapshot;
+ntapi_ldr_revert_state_to_snapshot __ntapi_ldr_revert_state_to_snapshot;
+
+/* nt_string.h */
+ntapi_tt_string_null_offset_multibyte __ntapi_tt_string_null_offset_multibyte;
+ntapi_tt_string_null_offset_short __ntapi_tt_string_null_offset_short;
+ntapi_tt_string_null_offset_dword __ntapi_tt_string_null_offset_dword;
+ntapi_tt_string_null_offset_qword __ntapi_tt_string_null_offset_qword;
+ntapi_tt_string_null_offset_ptrsize __ntapi_tt_string_null_offset_ptrsize;
+ntapi_wcslen __ntapi_wcslen;
+ntapi_tt_aligned_block_memset __ntapi_tt_aligned_block_memset;
+ntapi_tt_aligned_block_memcpy __ntapi_tt_aligned_block_memcpy;
+ntapi_tt_init_unicode_string_from_utf16 __ntapi_tt_init_unicode_string_from_utf16;
+ntapi_tt_memcpy_utf16 __ntapi_tt_memcpy_utf16;
+ntapi_tt_aligned_memcpy_utf16 __ntapi_tt_aligned_memcpy_utf16;
+ntapi_tt_generic_memset __ntapi_tt_generic_memset;
+ntapi_tt_generic_memcpy __ntapi_tt_generic_memcpy;
+ntapi_tt_uint16_to_hex_utf16 __ntapi_tt_uint16_to_hex_utf16;
+ntapi_tt_uint32_to_hex_utf16 __ntapi_tt_uint32_to_hex_utf16;
+ntapi_tt_uint64_to_hex_utf16 __ntapi_tt_uint64_to_hex_utf16;
+ntapi_tt_uintptr_to_hex_utf16 __ntapi_tt_uintptr_to_hex_utf16;
+ntapi_tt_hex_utf16_to_uint16 __ntapi_tt_hex_utf16_to_uint16;
+ntapi_tt_hex_utf16_to_uint32 __ntapi_tt_hex_utf16_to_uint32;
+ntapi_tt_hex_utf16_to_uint64 __ntapi_tt_hex_utf16_to_uint64;
+ntapi_tt_hex_utf16_to_uintptr __ntapi_tt_hex_utf16_to_uintptr;
+ntapi_tt_uint16_to_hex_utf8 __ntapi_tt_uint16_to_hex_utf8;
+ntapi_tt_uint32_to_hex_utf8 __ntapi_tt_uint32_to_hex_utf8;
+ntapi_tt_uint64_to_hex_utf8 __ntapi_tt_uint64_to_hex_utf8;
+ntapi_tt_uintptr_to_hex_utf8 __ntapi_tt_uintptr_to_hex_utf8;
+
+/* nt_guid.h */
+ntapi_tt_guid_to_utf16_string __ntapi_tt_guid_to_utf16_string;
+ntapi_tt_utf16_string_to_guid __ntapi_tt_utf16_string_to_guid;
+
+/* nt_sysinfo.h */
+ntapi_tt_get_system_directory_native_path __ntapi_tt_get_system_directory_native_path;
+ntapi_tt_get_system_directory_dos_path __ntapi_tt_get_system_directory_dos_path;
+ntapi_tt_get_system_directory_handle __ntapi_tt_get_system_directory_handle;
+ntapi_tt_get_system_info_snapshot __ntapi_tt_get_system_info_snapshot;
+
+/* nt_thread.h */
+ntapi_tt_create_thread __ntapi_tt_create_thread;
+ntapi_tt_create_local_thread __ntapi_tt_create_local_thread;
+ntapi_tt_create_remote_thread __ntapi_tt_create_remote_thread;
+
+/* nt_process.h */
+ntapi_tt_fork __ntapi_tt_fork_v1;
+ntapi_tt_fork __ntapi_tt_fork_v2;
+ntapi_tt_create_remote_process_params __ntapi_tt_create_remote_process_params;
+ntapi_tt_create_remote_runtime_data __ntapi_tt_create_remote_runtime_data;
+ntapi_tt_create_native_process __ntapi_tt_create_native_process_v1;
+ntapi_tt_create_native_process __ntapi_tt_create_native_process_v2;
+ntapi_tt_get_runtime_data __ntapi_tt_get_runtime_data;
+ntapi_tt_init_runtime_data __ntapi_tt_init_runtime_data;
+ntapi_tt_update_runtime_data __ntapi_tt_update_runtime_data;
+ntapi_tt_exec_map_image_as_data __ntapi_tt_exec_map_image_as_data;
+ntapi_tt_exec_unmap_image __ntapi_tt_exec_unmap_image;
+
+/* nt_section.h */
+ntapi_tt_get_section_name __ntapi_tt_get_section_name;
+
+/* nt_sync.h */
+ntapi_tt_create_inheritable_event __ntapi_tt_create_inheritable_event;
+ntapi_tt_create_private_event __ntapi_tt_create_private_event;
+ntapi_tt_wait_for_dummy_event __ntapi_tt_wait_for_dummy_event;
+ntapi_tt_sync_block_init __ntapi_tt_sync_block_init;
+ntapi_tt_sync_block_lock __ntapi_tt_sync_block_lock;
+ntapi_tt_sync_block_server_lock __ntapi_tt_sync_block_server_lock;
+ntapi_tt_sync_block_unlock __ntapi_tt_sync_block_unlock;
+ntapi_tt_sync_block_invalidate __ntapi_tt_sync_block_invalidate;
+
+/* nt_port.h */
+ntapi_tt_port_guid_from_type __ntapi_tt_port_guid_from_type;
+ntapi_tt_port_type_from_guid __ntapi_tt_port_type_from_guid;
+ntapi_tt_port_generate_keys __ntapi_tt_port_generate_keys;
+ntapi_tt_port_format_keys __ntapi_tt_port_format_keys;
+ntapi_tt_port_name_from_attributes __ntapi_tt_port_name_from_attributes;
+
+/* nt_argv.h */
+ntapi_tt_get_cmd_line_utf16 __ntapi_tt_get_cmd_line_utf16;
+ntapi_tt_get_peb_env_block_utf16 __ntapi_tt_get_peb_env_block_utf16;
+ntapi_tt_parse_cmd_line_args_utf16 __ntapi_tt_parse_cmd_line_args_utf16;
+ntapi_tt_get_argv_envp_utf8 __ntapi_tt_get_argv_envp_utf8;
+ntapi_tt_get_argv_envp_utf16 __ntapi_tt_get_argv_envp_utf16;
+ntapi_tt_get_env_var_meta_utf16 __ntapi_tt_get_env_var_meta_utf16;
+ntapi_tt_get_short_option_meta_utf16 __ntapi_tt_get_short_option_meta_utf16;
+ntapi_tt_get_long_option_meta_utf16 __ntapi_tt_get_long_option_meta_utf16;
+ntapi_tt_array_copy_utf8 __ntapi_tt_array_copy_utf8;
+ntapi_tt_array_copy_utf16 __ntapi_tt_array_copy_utf16;
+ntapi_tt_array_convert_utf8_to_utf16 __ntapi_tt_array_convert_utf8_to_utf16;
+ntapi_tt_array_convert_utf16_to_utf8 __ntapi_tt_array_convert_utf16_to_utf8;
+
+/* nt_blitter.h */
+ntapi_blt_alloc __ntapi_blt_alloc;
+ntapi_blt_free __ntapi_blt_free;
+ntapi_blt_acquire __ntapi_blt_acquire;
+ntapi_blt_obtain __ntapi_blt_obtain;
+ntapi_blt_possess __ntapi_blt_possess;
+ntapi_blt_release __ntapi_blt_release;
+ntapi_blt_get __ntapi_blt_get;
+ntapi_blt_set __ntapi_blt_set;
+
+/* nt_unicode.h */
+ntapi_uc_validate_unicode_stream_utf8 __ntapi_uc_validate_unicode_stream_utf8;
+ntapi_uc_validate_unicode_stream_utf16 __ntapi_uc_validate_unicode_stream_utf16;
+ntapi_uc_get_code_point_byte_count_utf8 __ntapi_uc_get_code_point_byte_count_utf8;
+ntapi_uc_get_code_point_byte_count_utf16 __ntapi_uc_get_code_point_byte_count_utf16;
+ntapi_uc_convert_unicode_stream_utf8_to_utf16 __ntapi_uc_convert_unicode_stream_utf8_to_utf16;
+ntapi_uc_convert_unicode_stream_utf8_to_utf32 __ntapi_uc_convert_unicode_stream_utf8_to_utf32;
+ntapi_uc_convert_unicode_stream_utf16_to_utf8 __ntapi_uc_convert_unicode_stream_utf16_to_utf8;
+ntapi_uc_convert_unicode_stream_utf16_to_utf32 __ntapi_uc_convert_unicode_stream_utf16_to_utf32;
+
+
+/* nt_daemon.h */
+ntapi_dsr_init __ntapi_dsr_init;
+ntapi_dsr_start __ntapi_dsr_start;
+ntapi_dsr_create_port __ntapi_dsr_create_port;
+ntapi_dsr_connect_internal_client __ntapi_dsr_connect_internal_client;
+ntapi_dsr_internal_client_connect __ntapi_dsr_internal_client_connect;
+
+/* nt_vfd.h */
+ntapi_vfd_dev_name_init __ntapi_vfd_dev_name_init;
+
+/* nt_tty.h */
+ntapi_tty_create_session __ntapi_tty_create_session;
+ntapi_tty_join_session __ntapi_tty_join_session;
+ntapi_tty_connect __ntapi_tty_connect;
+ntapi_tty_client_session_query __ntapi_tty_client_session_query;
+ntapi_tty_client_session_set __ntapi_tty_client_session_set;
+ntapi_tty_client_process_register __ntapi_tty_client_process_register;
+ntapi_tty_query_information_server __ntapi_tty_query_information_server;
+ntapi_tty_request_peer __ntapi_tty_request_peer;
+ntapi_tty_vms_query __ntapi_tty_vms_query;
+ntapi_tty_vms_request __ntapi_tty_vms_request;
+ntapi_pty_open __ntapi_pty_open;
+ntapi_pty_reopen __ntapi_pty_reopen;
+ntapi_pty_close __ntapi_pty_close;
+ntapi_pty_read __ntapi_pty_read;
+ntapi_pty_write __ntapi_pty_write;
+ntapi_pty_ioctl __ntapi_pty_ioctl;
+ntapi_pty_query __ntapi_pty_query;
+ntapi_pty_set __ntapi_pty_set;
+ntapi_pty_cancel __ntapi_pty_cancel;
+
+/* nt_socket.h */
+ntapi_sc_socket __ntapi_sc_socket_v1;
+ntapi_sc_socket __ntapi_sc_socket_v2;
+ntapi_sc_bind __ntapi_sc_bind_v1;
+ntapi_sc_bind __ntapi_sc_bind_v2;
+ntapi_sc_connect __ntapi_sc_connect_v1;
+ntapi_sc_connect __ntapi_sc_connect_v2;
+ntapi_sc_getsockname __ntapi_sc_getsockname_v1;
+ntapi_sc_getsockname __ntapi_sc_getsockname_v2;
+ntapi_sc_server_accept_connection __ntapi_sc_server_accept_connection_v1;
+ntapi_sc_server_accept_connection __ntapi_sc_server_accept_connection_v2;
+ntapi_sc_server_duplicate_socket __ntapi_sc_server_duplicate_socket;
+ntapi_sc_listen __ntapi_sc_listen;
+ntapi_sc_accept __ntapi_sc_accept;
+ntapi_sc_send __ntapi_sc_send;
+ntapi_sc_recv __ntapi_sc_recv;
+ntapi_sc_shutdown __ntapi_sc_shutdown;
+ntapi_sc_wait __ntapi_sc_wait;
+
+/* nt_mount.h */
+ntapi_tt_get_dos_drive_device_handle __ntapi_tt_get_dos_drive_device_handle;
+ntapi_tt_get_dos_drive_root_handle __ntapi_tt_get_dos_drive_root_handle;
+ntapi_tt_get_dos_drive_device_name __ntapi_tt_get_dos_drive_device_name;
+ntapi_tt_get_dos_drive_mount_points __ntapi_tt_get_dos_drive_mount_points;
+ntapi_tt_dev_mount_points_to_statfs __ntapi_tt_dev_mount_points_to_statfs;
+ntapi_tt_get_dos_drive_letter_from_device __ntapi_tt_get_dos_drive_letter_from_device;
+
+/* nt_istat.h */
+ntapi_tt_istat __ntapi_tt_istat;
+ntapi_tt_validate_fs_handle __ntapi_tt_validate_fs_handle;
+
+/* nt_stat.h */
+ntapi_tt_stat __ntapi_tt_stat;
+
+/* nt_statfs.h */
+ntapi_tt_statfs __ntapi_tt_statfs;
+
+/* nt_vmount.h */
+ntapi_vms_get_node_by_dev_name __ntapi_vms_get_node_by_dev_name;
+ntapi_vms_get_node_by_end_component __ntapi_vms_get_node_by_end_component;
+ntapi_vms_cache_alloc __ntapi_vms_cache_alloc;
+ntapi_vms_cache_free __ntapi_vms_cache_free;
+ntapi_vms_client_connect __ntapi_vms_client_connect;
+ntapi_vms_client_disconnect __ntapi_vms_client_disconnect;
+ntapi_vms_point_attach __ntapi_vms_point_attach;
+ntapi_vms_point_get_handles __ntapi_vms_point_get_handles;
+ntapi_vms_ref_count_inc __ntapi_vms_ref_count_inc;
+ntapi_vms_ref_count_dec __ntapi_vms_ref_count_dec;
+ntapi_vms_table_query __ntapi_vms_table_query;
+
+/* nt_hashes.h */
+ntapi_tt_populate_hashed_import_table __ntapi_tt_populate_hashed_import_table;
+
+/* nt_guid.h */
+ntapi_tt_guid_copy __ntapi_tt_guid_copy;
+ntapi_tt_guid_compare __ntapi_tt_guid_compare;
+ntapi_tt_guid_to_utf16_string __ntapi_tt_guid_to_utf16_string;
+ntapi_tt_utf16_string_to_guid __ntapi_tt_utf16_string_to_guid;
+
+/* debug */
+ntapi_dbg_write __dbg_write;
+ntapi_dbg_fn_call __dbg_fn_call;
+ntapi_dbg_msg __dbg_msg;
+
+/* csrss */
+ntapi_tt_get_csr_port_handle_addr_by_logic __GET_CSR_PORT_HANDLE_BY_LOGIC;
+ntapi_csr_port_handle __ntapi_csr_port_handle;
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/internal/ntapi_hash_table.h b/src/internal/ntapi_hash_table.h
new file mode 100644
index 0000000..727e4f2
--- /dev/null
+++ b/src/internal/ntapi_hash_table.h
@@ -0,0 +1,266 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#ifndef ___NTAPI_HASH_TABLE_H_
+#define ___NTAPI_HASH_TABLE_H_
+
+#include <psxtypes/psxtypes.h>
+
+#define __NTAPI_HASH_TABLE \
+ {0x000f6dee, (150)}, /* CsrPortHandle */ \
+ {0x00b3a87b, (30)}, /* ZwMapUserPhysicalPages */ \
+ {0x011c4489, (95)}, /* ZwPulseEvent */ \
+ {0x02513506, (39)}, /* ZwAreMappedFilesTheSame */ \
+ {0x034a4430, (63)}, /* RtlCreateProcessParameters */ \
+ {0x03bb7a3c, (187)}, /* ZwRestoreKey */ \
+ {0x04e21f45, (75)}, /* ZwCreateToken */ \
+ {0x04f94dc4, (190)}, /* ZwUnloadKey */ \
+ {0x06125322, (216)}, /* ZwAccessCheckByTypeResultListAndAuditAlarmByHandle */ \
+ {0x06b550e3, (146)}, /* ZwWriteRequestData */ \
+ {0x0708114b, (50)}, /* ZwTestAlert */ \
+ {0x08087626, (34)}, /* ZwOpenSection */ \
+ {0x08b1918f, (45)}, /* ZwSuspendThread */ \
+ {0x097e0efd, (154)}, /* ZwOpenFile */ \
+ {0x0a7a10d0, (88)}, /* ZwOpenTimer */ \
+ {0x0a83f5d6, (191)}, /* ZwQueryOpenSubKeys */ \
+ {0x0bd77556, (218)}, /* ZwSetThreadExecutionState */ \
+ {0x0c5cf449, (168)}, /* ZwQueryEaFile */ \
+ {0x0d638bd2, (74)}, /* ZwSetInformationJobObject */ \
+ {0x0e629eed, (102)}, /* ZwQuerySemaphore */ \
+ {0x11fcbb7c, (23)}, /* ZwReadVirtualMemory */ \
+ {0x124a301e, (16)}, /* ZwSetSystemEnvironmentValue */ \
+ {0x12ec66eb, (227)}, /* ZwQueryDefaultLocale */ \
+ {0x1742c5c9, (162)}, /* ZwWriteFileGather */ \
+ {0x177157e3, (42)}, /* ZwTerminateThread */ \
+ {0x1af41c1a, (22)}, /* ZwProtectVirtualMemory */ \
+ {0x1c0197e6, (233)}, /* ZwAllocateUuids */ \
+ {0x1c7a90a1, (5)}, /* ZwQuerySecurityObject */ \
+ {0x1cf668c5, (194)}, /* ZwQueryKey */ \
+ {0x2259fc62, (2)}, /* ZwDuplicateObject */ \
+ {0x24e09c64, (18)}, /* ZwSystemDebugControl */ \
+ {0x255bf138, (142)}, /* ZwReplyWaitReplyPort */ \
+ {0x25684721, (76)}, /* ZwOpenProcessToken */ \
+ {0x25d91d90, (71)}, /* ZwTerminateJobObject */ \
+ {0x26e1170e, (193)}, /* ZwSetInformationKey */ \
+ {0x27dd46c3, (29)}, /* ZwFreeUserPhysicalPages */ \
+ {0x2812eb3c, (232)}, /* ZwAllocateLocallyUniqueId */ \
+ {0x28574a3f, (77)}, /* ZwOpenThreadToken */ \
+ {0x29b5ea3d, (140)}, /* ZwRequestWaitReplyPort */ \
+ {0x2a6ac6fb, (26)}, /* ZwUnlockVirtualMemory */ \
+ {0x2aad9aed, (83)}, /* ZwSetInformationToken */ \
+ {0x2b2356f7, (52)}, /* ZwAlertResumeThread */ \
+ {0x2c0f001a, (230)}, /* ZwSetDefaultUILanguage */ \
+ {0x2f22b634, (96)}, /* ZwResetEvent */ \
+ {0x30309daa, (170)}, /* ZwCreateNamedPipeFile */ \
+ {0x3064d37b, (68)}, /* RtlQueryProcessDebugInformation */ \
+ {0x30911e3f, (196)}, /* ZwNotifyChangeKey */ \
+ {0x32ad44f5, (73)}, /* ZwQueryInformationJobObject */ \
+ {0x33a33c40, (163)}, /* ZwLockFile */ \
+ {0x357f8a82, (36)}, /* ZwExtendSection */ \
+ {0x3753c2c8, (198)}, /* ZwDeleteValueKey */ \
+ {0x379a6717, (93)}, /* ZwOpenEvent */ \
+ {0x391b8d79, (157)}, /* ZwCancelIoFile */ \
+ {0x3928a4cc, (20)}, /* ZwFreeVirtualMemory */ \
+ {0x39bea937, (89)}, /* ZwCancelTimer */ \
+ {0x3abffc38, (239)}, /* ZwFlushWriteBuffer */ \
+ {0x3b1f8d85, (124)}, /* ZwQueryTimerResolution */ \
+ {0x3d4aceeb, (248)}, /* memset */ \
+ {0x3e1d331d, (44)}, /* ZwSetInformationThread */ \
+ {0x3f62370b, (204)}, /* ZwPrivilegeCheck */ \
+ {0x416c4024, (118)}, /* ZwSetLowWaitHighEventPair */ \
+ {0x43c1745d, (92)}, /* ZwCreateEvent */ \
+ {0x43d65de2, (231)}, /* ZwQueryInstallUILanguage */ \
+ {0x45d7086f, (108)}, /* ZwOpenIoCompletion */ \
+ {0x465977c0, (129)}, /* ZwQueryIntervalProfile */ \
+ {0x47b3fd39, (8)}, /* ZwOpenDirectoryObject */ \
+ {0x47dd6896, (171)}, /* ZwCreateMailslotFile */ \
+ {0x49d62b40, (246)}, /* LdrLoadDll */ \
+ {0x4a638203, (91)}, /* ZwQueryTimer */ \
+ {0x4c51093e, (189)}, /* ZwLoadKey2 */ \
+ {0x4cb0ea34, (206)}, /* ZwPrivilegedServiceAuditAlarm */ \
+ {0x4cc741f4, (222)}, /* ZwPowerInformation */ \
+ {0x4d0aa736, (207)}, /* ZwAccessCheck */ \
+ {0x4d361035, (181)}, /* ZwCreateKey */ \
+ {0x4de0faef, (10)}, /* ZwCreateSymbolicLinkObject */ \
+ {0x4e049b9b, (72)}, /* ZwAssignProcessToJobObject */ \
+ {0x4ed4c833, (0)}, /* ZwQueryObject */ \
+ {0x4efff89a, (166)}, /* ZwFsControlFile */ \
+ {0x4fe5a956, (49)}, /* ZwQueueApcThread */ \
+ {0x50f7777d, (84)}, /* ZwWaitForSingleObject */ \
+ {0x513877ab, (61)}, /* ZwSetInformationProcess */ \
+ {0x51d5c98d, (137)}, /* ZwAcceptConnectPort */ \
+ {0x51ddffce, (242)}, /* ZwDisplayString */ \
+ {0x51fbe1c4, (165)}, /* ZwDeviceIoControlFile */ \
+ {0x52334a05, (213)}, /* ZwDeleteObjectAuditAlarm */ \
+ {0x5288a7cf, (46)}, /* ZwResumeThread */ \
+ {0x54a89e87, (131)}, /* ZwStopProfile */ \
+ {0x56ada303, (185)}, /* ZwSaveKey */ \
+ {0x57dd87c6, (114)}, /* ZwWaitLowEventPair */ \
+ {0x5879157d, (241)}, /* ZwSetDefaultHardErrorPort */ \
+ {0x58b766a7, (200)}, /* ZwQueryValueKey */ \
+ {0x59d0cf7f, (9)}, /* ZwQueryDirectoryObject */ \
+ {0x5a201018, (180)}, /* ZwSetInformationFile */ \
+ {0x5b24a650, (155)}, /* ZwDeleteFile */ \
+ {0x5cc5b0cc, (149)}, /* CsrClientCallServer */ \
+ {0x5ccb443b, (245)}, /* ZwVdmControl */ \
+ {0x5d5b0c74, (15)}, /* ZwQuerySystemEnvironmentValue */ \
+ {0x5dcf9e33, (205)}, /* ZwPrivilegeObjectAuditAlarm */ \
+ {0x5f3fb511, (164)}, /* ZwUnlockFile */ \
+ {0x60ebf65f, (120)}, /* ZwQuerySystemTime */ \
+ {0x63033516, (244)}, /* ZwSetLdtEntries */ \
+ {0x63cc9e64, (66)}, /* RtlCreateQueryDebugBuffer */ \
+ {0x64a2ceb5, (56)}, /* ZwCreateProcess */ \
+ {0x654da6fd, (143)}, /* ZwReplyWaitReceivePort */ \
+ {0x6570064e, (243)}, /* ZwCreatePagingFile */ \
+ {0x65b5374b, (14)}, /* ZwSetSystemInformation */ \
+ {0x6a2d88fc, (126)}, /* ZwYieldExecution */ \
+ {0x6c1b25c0, (97)}, /* ZwClearEvent */ \
+ {0x6db16208, (238)}, /* ZwQueryInformationAtom */ \
+ {0x6e0c0f9d, (65)}, /* RtlNormalizeProcessParams */ \
+ {0x6f11895e, (217)}, /* ZwIsSystemResumeAutomatic */ \
+ {0x7160272d, (144)}, /* ZwReplyWaitReceivePortEx */ \
+ {0x72f83a29, (67)}, /* RtlDestroyQueryDebugBuffer */ \
+ {0x73349dea, (160)}, /* ZwWriteFile */ \
+ {0x75e01428, (111)}, /* ZwQueryIoCompletion */ \
+ {0x75e970e4, (115)}, /* ZwSetLowEventPair */ \
+ {0x7683000f, (38)}, /* ZwUnmapViewOfSection */ \
+ {0x76d9a68b, (159)}, /* ZwReadFile */ \
+ {0x7783f5c4, (98)}, /* ZwQueryEvent */ \
+ {0x78327b0d, (173)}, /* ZwSetVolumeInformationFile */ \
+ {0x78a28538, (80)}, /* ZwAdjustPrivilegesToken */ \
+ {0x7b9f9b64, (182)}, /* ZwOpenKey */ \
+ {0x7ccd8968, (138)}, /* ZwCompleteConnectPort */ \
+ {0x7dfb3677, (169)}, /* ZwSetEaFile */ \
+ {0x7e21039a, (87)}, /* ZwCreateTimer */ \
+ {0x7ec723c2, (122)}, /* ZwQueryPerformanceCounter */ \
+ {0x7f99ab33, (145)}, /* ZwReadRequestData */ \
+ {0x81b18dcd, (21)}, /* ZwQueryVirtualMemory */ \
+ {0x842e9cbb, (43)}, /* ZwQueryInformationThread */ \
+ {0x84d52359, (112)}, /* ZwCreateEventPair */ \
+ {0x84e3898f, (183)}, /* ZwDeleteKey */ \
+ {0x850106f7, (7)}, /* ZwCreateDirectoryObject */ \
+ {0x8548dfbd, (106)}, /* ZwQueryMutant */ \
+ {0x85f069ec, (197)}, /* ZwNotifyChangeMultipleKeys */ \
+ {0x87763935, (249)}, /* sprintf */ \
+ {0x87fd0a60, (24)}, /* ZwWriteVirtualMemory */ \
+ {0x8a1989d8, (136)}, /* ZwListenPort */ \
+ {0x8afaa2ca, (31)}, /* ZwGetWriteWatch */ \
+ {0x8b3aacc6, (174)}, /* ZwQueryQuotaInformationFile */ \
+ {0x8bf01eb2, (135)}, /* ZwSecureConnectPort */ \
+ {0x8c4a9ca2, (100)}, /* ZwOpenSemaphore */ \
+ {0x8cb632f5, (17)}, /* ZwShutdownSystem */ \
+ {0x8d31519d, (58)}, /* ZwOpenProcess */ \
+ {0x8d5b0647, (53)}, /* ZwRegisterThreadTerminatePort */ \
+ {0x8df4b3ed, (158)}, /* ZwCancelIoFileEx */ \
+ {0x8e80b080, (119)}, /* ZwSetHighWaitLowEventPair */ \
+ {0x8eb2c33b, (121)}, /* ZwSetSystemTime */ \
+ {0x8fe01ce6, (4)}, /* ZwClose */ \
+ {0x8ffaebe4, (70)}, /* ZwOpenJobObject */ \
+ {0x90bf911c, (177)}, /* ZwQueryFullAttributesFile */ \
+ {0x920b0183, (116)}, /* ZwWaitHighEventPair */ \
+ {0x9331fae3, (25)}, /* ZwLockVirtualMemory */ \
+ {0x9384c236, (103)}, /* ZwCreateMutant */ \
+ {0x93e64266, (130)}, /* ZwStartProfile */ \
+ {0x949f76b6, (19)}, /* ZwAllocateVirtualMemory */ \
+ {0x956ba548, (11)}, /* ZwOpenSymbolicLinkObject */ \
+ {0x963cafbc, (229)}, /* ZwQueryDefaultUILanguage */ \
+ {0x9731aded, (178)}, /* ZwQueryDirectoryFile */ \
+ {0x978855cd, (37)}, /* ZwMapViewOfSection */ \
+ {0x98058c5c, (86)}, /* ZwWaitForMultipleObjects */ \
+ {0x997388d8, (237)}, /* ZwDeleteAtom */ \
+ {0x9bf04a73, (172)}, /* ZwQueryVolumeInformationFile */ \
+ {0x9c805856, (167)}, /* ZwNotifyChangeDirectoryFile */ \
+ {0x9d9c64db, (186)}, /* ZwSaveMergedKeys */ \
+ {0x9fb42181, (79)}, /* ZwFilterToken */ \
+ {0x9fce5072, (57)}, /* ZwCreateUserProcess */ \
+ {0xa09dea3c, (192)}, /* ZwReplaceKey */ \
+ {0xa313f9b0, (220)}, /* ZwSetSystemPowerState */ \
+ {0xa34a43e1, (48)}, /* ZwSetContextThread */ \
+ {0xa51616fd, (156)}, /* ZwFlushBuffersFile */ \
+ {0xa589ce00, (226)}, /* ZwContinue */ \
+ {0xa5b2c609, (117)}, /* ZwSetHighEventPair */ \
+ {0xa8720028, (153)}, /* ZwCreateFile */ \
+ {0xa93301f4, (110)}, /* ZwRemoveIoCompletion */ \
+ {0xa9e5e651, (199)}, /* ZwSetValueKey */ \
+ {0xabc87b74, (32)}, /* ZwResetWriteWatch */ \
+ {0xac5765bd, (211)}, /* ZwOpenObjectAuditAlarm */ \
+ {0xac77c9d4, (47)}, /* ZwGetContextThread */ \
+ {0xaccf3eee, (214)}, /* ZwAccessCheckByTypeAndAuditAlarm */ \
+ {0xacdddfe2, (176)}, /* ZwQueryAttributesFile */ \
+ {0xafe64c80, (179)}, /* ZwQueryInformationFile */ \
+ {0xb28fcd19, (1)}, /* ZwSetInformationObject */ \
+ {0xb2adc219, (209)}, /* ZwAccessCheckByType */ \
+ {0xb32b8a16, (41)}, /* ZwOpenThread */ \
+ {0xb39f2b58, (128)}, /* ZwSetIntervalProfile */ \
+ {0xb3a5ef4c, (64)}, /* RtlDestroyProcessParameters */ \
+ {0xb3d90f63, (60)}, /* ZwQueryInformationProcess */ \
+ {0xb3f8b8ba, (184)}, /* ZwFlushKey */ \
+ {0xb468e7d0, (225)}, /* ZwRaiseException */ \
+ {0xb4f463e1, (175)}, /* ZwSetQuotaInformationFile */ \
+ {0xb5ce95b0, (109)}, /* ZwSetIoCompletion */ \
+ {0xb677bd15, (219)}, /* ZwGetDevicePowerState */ \
+ {0xb891d19c, (141)}, /* ZwReplyPort */ \
+ {0xba08cfed, (221)}, /* ZwInitiatePowerAction */ \
+ {0xba5bdfc3, (234)}, /* ZwSetUuidSeed */ \
+ {0xbc310050, (133)}, /* ZwCreateWaitablePort */ \
+ {0xbde7d8d1, (151)}, /* ZwLoadDriver */ \
+ {0xbe9990b9, (134)}, /* ZwConnectPort */ \
+ {0xc0040fd0, (90)}, /* ZwSetTimer */ \
+ {0xc00fc05c, (240)}, /* ZwRaiseHardError */ \
+ {0xc4bd0fda, (99)}, /* ZwCreateSemaphore */ \
+ {0xc524def2, (148)}, /* ZwImpersonateClientOfPort */ \
+ {0xc6a277e0, (236)}, /* ZwFindAtom */ \
+ {0xc6de9ce3, (139)}, /* ZwRequestPort */ \
+ {0xc707f028, (27)}, /* ZwFlushVirtualMemory */ \
+ {0xc70d789c, (69)}, /* ZwCreateJobObject */ \
+ {0xc71b989a, (78)}, /* ZwDuplicateToken */ \
+ {0xc7835b75, (195)}, /* ZwEnumerateKey */ \
+ {0xc7d8afa4, (85)}, /* ZwSignalAndWaitForSingleObject */ \
+ {0xc94ea8a6, (81)}, /* ZwAdjustGroupsToken */ \
+ {0xc9f42a5d, (235)}, /* ZwAddAtom */ \
+ {0xca250552, (210)}, /* ZwAccessCheckByTypeResultList */ \
+ {0xcaf1f803, (152)}, /* ZwUnloadDriver */ \
+ {0xcb3c8251, (223)}, /* ZwPlugPlayControl */ \
+ {0xcc22b021, (113)}, /* ZwOpenEventPair */ \
+ {0xcdb98ed4, (59)}, /* ZwTerminateProcess */ \
+ {0xced9d11d, (123)}, /* ZwSetTimerResolution */ \
+ {0xd4191071, (127)}, /* ZwCreateProfile */ \
+ {0xd48a2bbc, (40)}, /* ZwCreateThread */ \
+ {0xd517401d, (54)}, /* ZwImpersonateThread */ \
+ {0xd5a16cee, (51)}, /* ZwAlertThread */ \
+ {0xd628c8f6, (228)}, /* ZwSetDefaultLocale */ \
+ {0xd7fef93d, (201)}, /* ZwEnumerateValueKey */ \
+ {0xda57df71, (247)}, /* LdrUnloadDll */ \
+ {0xdaa7575e, (215)}, /* ZwAccessCheckByTypeResultListAndAuditAlarm */ \
+ {0xde07d08f, (224)}, /* ZwGetPlugPlayEvent */ \
+ {0xde5468ed, (202)}, /* ZwQueryMultipleValueKey */ \
+ {0xdf8698ed, (13)}, /* ZwQuerySystemInformation */ \
+ {0xdf86b31f, (6)}, /* ZwSetSecurityObject */ \
+ {0xe0c1d02e, (55)}, /* ZwImpersonateAnonymousToken */ \
+ {0xe1562f17, (3)}, /* ZwMakeTemporaryObject */ \
+ {0xe19be90e, (33)}, /* ZwCreateSection */ \
+ {0xe23ef886, (161)}, /* ZwReadFileScatter */ \
+ {0xe2ff4b82, (188)}, /* ZwLoadKey */ \
+ {0xe3521fd4, (101)}, /* ZwReleaseSemaphore */ \
+ {0xe3624a9b, (212)}, /* ZwCloseObjectAuditAlarm */ \
+ {0xe3ae76c7, (132)}, /* ZwCreatePort */ \
+ {0xe43a3a6f, (147)}, /* ZwQueryInformationPort */ \
+ {0xe624ac47, (12)}, /* ZwQuerySymbolicLinkObject */ \
+ {0xe6a6cc2d, (208)}, /* ZwAccessCheckAndAuditAlarm */ \
+ {0xe8d1aec4, (105)}, /* ZwReleaseMutant */ \
+ {0xeb69e74d, (62)}, /* ZwFlushInstructionCache */ \
+ {0xed4a67c1, (28)}, /* ZwAllocateUserPhysicalPages */ \
+ {0xed5deedd, (107)}, /* ZwCreateIoCompletion */ \
+ {0xedac7230, (203)}, /* ZwInitializeRegistry */ \
+ {0xee535edc, (35)}, /* ZwQuerySection */ \
+ {0xee5cdc2d, (82)}, /* ZwQueryInformationToken */ \
+ {0xf3d1faa7, (125)}, /* ZwDelayExecution */ \
+ {0xf425639c, (104)}, /* ZwOpenMutant */ \
+ {0xfde47817, (94)}, /* ZwSetEvent */ \
+
+#define __NT_IMPORTED_SYMBOLS_ARRAY_SIZE 250
+
+#endif
diff --git a/src/internal/ntapi_impl.h b/src/internal/ntapi_impl.h
new file mode 100644
index 0000000..b60fc66
--- /dev/null
+++ b/src/internal/ntapi_impl.h
@@ -0,0 +1,120 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#ifndef ___NTAPI_IMPL_H_
+#define ___NTAPI_IMPL_H_
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_sysinfo.h>
+#include <ntapi/nt_thread.h>
+#include <ntapi/nt_process.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_hash_table.h"
+#include "ntapi_context.h"
+#include "ntapi_fnapi.h"
+
+#define __NT_BASED_NAMED_OBJECTS {'\\','B','a','s','e', \
+ 'N','a','m','e','d', \
+ 'O','b','j','e','c','t','s'}
+
+/* helper macros */
+#define __NT_ROUND_UP_TO_POWER_OF_2(x,y)(x + (y-1)) & ~(y-1)
+#define __NT_IS_MISALIGNED_BUFFER(x) ((!(uintptr_t)x) || ((uintptr_t)x % sizeof(size_t)))
+#define __NT_IS_MISALIGNED_LENGTH(x) (x % sizeof(size_t))
+#define __NT_FILE_SYNC_IO (NT_FILE_SYNCHRONOUS_IO_ALERT|NT_FILE_SYNCHRONOUS_IO_NONALERT)
+
+/* user-defined options: head */
+#ifndef __NT_TTY_MONITORS
+#define __NT_TTY_MONITORS 0x10
+#endif
+
+#ifndef __NT_FORK_CHILD_WAIT_MILLISEC
+#define __NT_FORK_CHILD_WAIT_MILLISEC 60000
+#endif
+
+#ifndef __NT_SYNC_BLOCK_LOCK_TRIES
+#define __NT_SYNC_BLOCK_LOCK_TRIES 1024
+#endif
+/* user-defined options: tail */
+
+/* internal page size */
+#ifndef __NT_INTERNAL_PAGE_SIZE
+#define __NT_INTERNAL_PAGE_SIZE 4096
+#endif
+
+/* .bss section */
+#ifndef __NT_BSS_RESERVED_PAGES
+#define __NT_BSS_RESERVED_PAGES 8
+#endif
+
+/* runtime buffers */
+#define __NT_BSS_ARGV_BUFFER_SIZE __NT_INTERNAL_PAGE_SIZE * 2
+
+#define __NT_BSS_ARGV_MAX_IDX __NT_BSS_ARGV_BUFFER_SIZE \
+ / sizeof(uintptr_t)
+
+#define __NT_BSS_ARGS_BUFFER_SIZE __NT_INTERNAL_PAGE_SIZE \
+ * __NT_BSS_RESERVED_PAGES \
+ - __NT_BSS_ARGV_BUFFER_SIZE
+
+/* ntapi .bss section structure */
+typedef struct ___ntapi_img_sec_bss {
+ wchar16_t * argv_envp_array[__NT_BSS_ARGV_MAX_IDX];
+ char args_envs_buffer[__NT_BSS_ARGS_BUFFER_SIZE];
+} __ntapi_img_sec_bss;
+
+
+/* ntapi library internals */
+typedef struct __attr_ptr_size_aligned__ _ntapi_internals {
+ nt_runtime_data * rtdata;
+ nt_port_name * subsystem;
+ void * hport_tty_session;
+ void * hport_tty_daemon;
+ void * hport_tty_debug;
+ void * hport_tty_monitor[__NT_TTY_MONITORS];
+ size_t nt_mem_page_size;
+ size_t nt_mem_allocation_granularity;
+ size_t ntapi_internals_alloc_size;
+ void ** csr_port_handle_addr;
+ void * hdev_mount_point_mgr;
+ void * hany[8];
+ intptr_t hlock;
+ uintptr_t v1_pipe_counter;
+ ntapi_tt_get_csr_port_handle_addr_by_logic * tt_get_csr_port_handle_addr_by_logic;
+ __ntapi_img_sec_bss * ntapi_img_sec_bss;
+} ntapi_internals;
+
+
+/* __ntapi_img_sec_data */
+typedef struct __attr_ptr_size_aligned__ ___ntapi_img_sec_rdata {
+ ntapi_hashed_symbol __ntapi_import_table[__NT_IMPORTED_SYMBOLS_ARRAY_SIZE];
+ ntapi_vtbl * __ntapi;
+ nt_port_name __session_name;
+ ntapi_internals * __internals;
+} __ntapi_img_sec_rdata;
+
+union __ntapi_img_rdata {
+ __ntapi_img_sec_rdata img_sec_data;
+ char buffer[__NT_INTERNAL_PAGE_SIZE];
+};
+
+
+/* accessor table */
+extern ntapi_vtbl ___ntapi;
+extern ntapi_vtbl ___ntapi_shadow;
+#define __ntapi (&___ntapi)
+
+
+/* access to library internals */
+ntapi_internals * __cdecl __ntapi_internals(void);
+
+
+/* debug */
+#define __ntidx(x) (&(((ntapi_vtbl *)0)->x)) / sizeof(size_t)
+
+
+#endif
diff --git a/src/internal/ntapi_lib_entry_point.c b/src/internal/ntapi_lib_entry_point.c
new file mode 100644
index 0000000..8b857c8
--- /dev/null
+++ b/src/internal/ntapi_lib_entry_point.c
@@ -0,0 +1,12 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+
+int __stdcall __ntapi_entry(void * hinstance, uint32_t reason, void * reserved)
+{
+ return 1;
+}
diff --git a/src/internal/ntapi_pty.h b/src/internal/ntapi_pty.h
new file mode 100644
index 0000000..ff85b3a
--- /dev/null
+++ b/src/internal/ntapi_pty.h
@@ -0,0 +1,37 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#ifndef ___NTAPI_PTY_H_
+#define ___NTAPI_PTY_H_
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_guid.h>
+#include <ntapi/nt_sync.h>
+#include <ntapi/nt_tty.h>
+
+#define __PTY_READ 0
+#define __PTY_WRITE 1
+
+typedef struct nt_pty_context {
+ nt_sync_block sync[2];
+ void * addr;
+ size_t size;
+ void * hport;
+ void * hpty;
+ void * section;
+ void * section_addr;
+ size_t section_size;
+ nt_guid guid;
+ nt_luid luid;
+ uint32_t access;
+ uint32_t flags;
+ uint32_t share;
+ uint32_t options;
+ nt_iosb iosb;
+} nt_pty;
+
+#endif
diff --git a/src/ipc/ntapi_tt_create_pipe_v1.c b/src/ipc/ntapi_tt_create_pipe_v1.c
new file mode 100644
index 0000000..3185fbd
--- /dev/null
+++ b/src/ipc/ntapi_tt_create_pipe_v1.c
@@ -0,0 +1,164 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_string.h>
+#include <ntapi/nt_atomic.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+
+typedef struct __attr_ptr_size_aligned__ _nt_tty_pipe_name {
+ wchar16_t pipe_dir[8];
+ wchar16_t back_slash;
+ wchar16_t key_1st[8];
+ wchar16_t uscore_1st;
+ wchar16_t key_2nd[8];
+ wchar16_t uscore_2nd;
+ wchar16_t key_3rd[8];
+ wchar16_t uscore_3rd;
+ wchar16_t key_4th[8];
+ wchar16_t uscore_4th;
+ wchar16_t key_5th[8];
+ wchar16_t uscore_5th;
+ wchar16_t key_6th[8];
+ wchar16_t null_termination;
+} nt_tty_pipe_name;
+
+
+int32_t __stdcall __ntapi_ipc_create_pipe_v1(
+ __out void ** hpipe_read,
+ __out void ** hpipe_write,
+ __in uint32_t advisory_buffer_size __optional)
+{
+ int32_t status;
+
+ void * hread;
+ void * hwrite;
+
+ nt_object_attributes oa;
+ nt_io_status_block iosb;
+ nt_unicode_string nt_name;
+ nt_security_quality_of_service sqos;
+ nt_large_integer timeout;
+ intptr_t * counter;
+
+ nt_tty_pipe_name pipe_name = {
+ {'\\','?','?','\\','p','i','p','e'},
+ '\\',
+ {0},'_',
+ {0},'_',
+ {0},'_',
+ {0},'_',
+ {0},'_',
+ {0},
+ 0
+ };
+
+ /* pipe_count */
+ counter = (intptr_t *)&__ntapi_internals()->v1_pipe_counter;
+ at_locked_inc(counter);
+
+ /* get system time */
+ status = __ntapi->zw_query_system_time(&timeout);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ /* pipe name (no anonymous pipe prior to vista) */
+ __ntapi->tt_uint32_to_hex_utf16( pe_get_current_process_id(),pipe_name.key_1st);
+ __ntapi->tt_uint32_to_hex_utf16( pe_get_current_thread_id(),pipe_name.key_2nd);
+
+ __ntapi->tt_uint32_to_hex_utf16( timeout.ihigh + (uint32_t)*counter,pipe_name.key_3rd);
+ __ntapi->tt_uint32_to_hex_utf16(timeout.ulow + (uint32_t)*counter,pipe_name.key_4th);
+
+ __ntapi->tt_uint32_to_hex_utf16(
+ __ntapi->tt_buffer_crc32(0,(char *)&pipe_name,sizeof(pipe_name)),
+ pipe_name.key_5th);
+
+ __ntapi->tt_uint32_to_hex_utf16(
+ __ntapi->tt_buffer_crc32(0,(char *)&pipe_name,sizeof(pipe_name)),
+ pipe_name.key_6th);
+
+ __ntapi->tt_uint32_to_hex_utf16(
+ __ntapi->tt_buffer_crc32(0,(char *)&pipe_name,sizeof(pipe_name)),
+ pipe_name.key_1st);
+
+ __ntapi->tt_uint32_to_hex_utf16(
+ __ntapi->tt_buffer_crc32(0,(char *)&pipe_name,sizeof(pipe_name)),
+ pipe_name.key_2nd);
+
+ __ntapi->tt_uint32_to_hex_utf16(
+ __ntapi->tt_buffer_crc32(0,(char *)&pipe_name,sizeof(pipe_name)),
+ pipe_name.key_3rd);
+
+ __ntapi->tt_uint32_to_hex_utf16(
+ __ntapi->tt_buffer_crc32(0,(char *)&pipe_name,sizeof(pipe_name)),
+ pipe_name.key_4th);
+
+ /* nt_name */
+ nt_name.strlen = (uint16_t)(sizeof(pipe_name) - sizeof(wchar16_t));
+ nt_name.maxlen = (uint16_t)(sizeof(pipe_name));
+ nt_name.buffer = (uint16_t *)&pipe_name;
+
+ /* init security structure */
+ sqos.length = sizeof(sqos);
+ sqos.impersonation_level = NT_SECURITY_IMPERSONATION;
+ sqos.context_tracking_mode = NT_SECURITY_TRACKING_DYNAMIC;
+ sqos.effective_only = 1;
+
+ /* oa */
+ oa.len = sizeof(oa);
+ oa.root_dir = (void *)0;
+ oa.obj_name = &nt_name;
+ oa.obj_attr = 0x0;
+ oa.sec_desc = (nt_security_descriptor *)0;
+ oa.sec_qos = &sqos;
+
+ timeout.ihigh = 0xffffffff;
+ timeout.ulow = 0x0;
+
+ /* the reading end */
+ status = __ntapi->zw_create_named_pipe_file(
+ &hread,
+ NT_GENERIC_READ | NT_SEC_SYNCHRONIZE | NT_FILE_WRITE_ATTRIBUTES,
+ &oa,
+ &iosb,
+ NT_FILE_SHARE_READ | NT_FILE_SHARE_WRITE,
+ NT_FILE_CREATE,
+ NT_FILE_ASYNCHRONOUS_IO,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0x2000,
+ 0x2000,
+ &timeout);
+
+ if (status != NT_STATUS_SUCCESS) {
+ return status;
+ }
+
+ /* the writing end(s) */
+ status = __ntapi->zw_open_file(
+ &hwrite,
+ NT_GENERIC_WRITE | NT_SEC_SYNCHRONIZE | NT_FILE_READ_ATTRIBUTES,
+ &oa,
+ &iosb,
+ NT_FILE_SHARE_READ | NT_FILE_SHARE_WRITE,
+ NT_FILE_WRITE_THROUGH | NT_FILE_ASYNCHRONOUS_IO | NT_FILE_NON_DIRECTORY_FILE);
+
+ if (status != NT_STATUS_SUCCESS) {
+ __ntapi->zw_close(hread);
+ return status;
+ }
+
+ *hpipe_read = hread;
+ *hpipe_write = hwrite;
+
+ return status;
+}
diff --git a/src/ipc/ntapi_tt_create_pipe_v2.c b/src/ipc/ntapi_tt_create_pipe_v2.c
new file mode 100644
index 0000000..c1f4b4b
--- /dev/null
+++ b/src/ipc/ntapi_tt_create_pipe_v2.c
@@ -0,0 +1,116 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_string.h>
+#include <ntapi/nt_tty.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_ipc_create_pipe_v2(
+ __out void ** hpipe_read,
+ __out void ** hpipe_write,
+ __in uint32_t advisory_buffer_size __optional)
+{
+ int32_t status;
+
+ void * hdevpipes;
+ void * hwrite;
+ void * hread;
+
+ nt_object_attributes oa;
+ nt_io_status_block iosb;
+ nt_sqos sqos;
+ nt_unicode_string nt_name;
+ nt_large_integer timeout;
+
+ const wchar16_t pipe_dir[] = {
+ '\\','D','e','v','i','c','e',
+ '\\','N','a','m','e','d','P','i','p','e','\\',0
+ };
+
+ /* nt_name: pipe device directory */
+ nt_name.strlen = (uint16_t)(sizeof(pipe_dir) - sizeof(wchar16_t));
+ nt_name.maxlen = 0;
+ nt_name.buffer = (uint16_t *)pipe_dir;
+
+ /* init security structure */
+ sqos.length = sizeof(sqos);
+ sqos.impersonation_level = NT_SECURITY_IMPERSONATION;
+ sqos.context_tracking_mode = NT_SECURITY_TRACKING_DYNAMIC;
+ sqos.effective_only = 1;
+
+ /* oa */
+ oa.len = sizeof(oa);
+ oa.root_dir = (void *)0;
+ oa.obj_name = &nt_name;
+ oa.obj_attr = NT_OBJ_CASE_INSENSITIVE | NT_OBJ_INHERIT;
+ oa.sec_desc = (nt_security_descriptor *)0;
+ oa.sec_qos = &sqos;
+
+ status = __ntapi->zw_open_file(
+ &hdevpipes,
+ NT_GENERIC_READ | NT_SEC_SYNCHRONIZE,
+ &oa,
+ &iosb,
+ NT_FILE_SHARE_READ | NT_FILE_SHARE_WRITE,
+ NT_FILE_DIRECTORY_FILE);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ timeout.ihigh = 0xffffffff;
+ timeout.ulow = 0x0;
+
+ oa.root_dir = hdevpipes;
+
+ nt_name.strlen=0;
+ nt_name.buffer = (uint16_t *)0;
+
+ status = __ntapi->zw_create_named_pipe_file(
+ &hread,
+ NT_GENERIC_READ | NT_SEC_SYNCHRONIZE | NT_FILE_WRITE_ATTRIBUTES,
+ &oa,
+ &iosb,
+ NT_FILE_SHARE_READ | NT_FILE_SHARE_WRITE,
+ NT_FILE_CREATE,
+ NT_FILE_ASYNCHRONOUS_IO,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0X2000,
+ 0x2000,
+ &timeout);
+
+ if (status != NT_STATUS_SUCCESS) {
+ __ntapi->zw_close(hdevpipes);
+ return status;
+ }
+
+ /* the pipe is now our root directory */
+ oa.root_dir = hread;
+
+ status = __ntapi->zw_open_file(
+ &hwrite,
+ NT_GENERIC_WRITE | NT_SEC_SYNCHRONIZE | NT_FILE_READ_ATTRIBUTES,
+ &oa,
+ &iosb,
+ NT_FILE_SHARE_READ | NT_FILE_SHARE_WRITE,
+ NT_FILE_WRITE_THROUGH | NT_FILE_ASYNCHRONOUS_IO | NT_FILE_NON_DIRECTORY_FILE);
+
+ if (status != NT_STATUS_SUCCESS) {
+ __ntapi->zw_close(hdevpipes);
+ __ntapi->zw_close(hread);
+ return status;
+ }
+
+ *hpipe_read = hread;
+ *hpipe_write = hwrite;
+
+ return status;
+}
diff --git a/src/ldr/ntapi_ldr_create_state_snapshot.c b/src/ldr/ntapi_ldr_create_state_snapshot.c
new file mode 100644
index 0000000..74a916c
--- /dev/null
+++ b/src/ldr/ntapi_ldr_create_state_snapshot.c
@@ -0,0 +1,69 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <pemagine/pemagine.h>
+#include <dalist/dalist.h>
+#include <ntapi/ntapi.h>
+
+struct callback_ctx {
+ struct dalist_ex * ldr_state_snapshot;
+ int32_t status;
+};
+
+static int __cdecl __add_module_base_address_to_list(
+ struct pe_ldr_tbl_entry * ldr_tbl_entry,
+ enum pe_callback_reason int_callback_reason,
+ void * context)
+{
+ struct dalist_node * node;
+ struct callback_ctx * ctx;
+
+ ctx = (struct callback_ctx *)context;
+
+ if (int_callback_reason == PE_CALLBACK_REASON_ERROR) {
+ ctx->status = NT_STATUS_UNSUCCESSFUL;
+ return ctx->status;
+ } else if (int_callback_reason != PE_CALLBACK_REASON_ITEM) {
+ ctx->status = NT_STATUS_SUCCESS;
+ return 1;
+ } else if (!ldr_tbl_entry->dll_base) {
+ ctx->status = NT_STATUS_SUCCESS;
+ return 1;
+ }
+
+ ctx->status = dalist_get_node_by_key(
+ ctx->ldr_state_snapshot,
+ (struct dalist_node_ex **)&node,
+ (uintptr_t)ldr_tbl_entry->dll_base,
+ DALIST_NODE_TYPE_NEW,
+ 0);
+
+ if (ctx->status != DALIST_OK)
+ return -1;
+ else
+ return 1;
+}
+
+
+int __cdecl __ntapi_ldr_create_state_snapshot(
+ __out struct dalist_ex * ldr_state_snapshot)
+{
+ struct callback_ctx ctx;
+
+ if (!ldr_state_snapshot->free && !ldr_state_snapshot->memfn_ptr)
+ return NT_STATUS_BUFFER_TOO_SMALL;
+ else if (ldr_state_snapshot->info.list_nodes)
+ return NT_STATUS_INVALID_USER_BUFFER;
+
+ ctx.ldr_state_snapshot = ldr_state_snapshot;
+
+ pe_enum_modules_in_load_order(
+ __add_module_base_address_to_list,
+ &ctx);
+
+ return ctx.status;
+}
diff --git a/src/ldr/ntapi_ldr_load_system_dll.c b/src/ldr/ntapi_ldr_load_system_dll.c
new file mode 100644
index 0000000..d417590
--- /dev/null
+++ b/src/ldr/ntapi_ldr_load_system_dll.c
@@ -0,0 +1,44 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_ldr.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_ldr_load_system_dll(
+ __in void * hsysdir __optional,
+ __in wchar16_t * base_name,
+ __in uint32_t base_name_size,
+ __in uint32_t * image_flags __optional,
+ __out void ** image_base)
+{
+ int32_t status;
+ nt_unicode_string nt_image_name;
+ uintptr_t buffer[0x80];
+
+ /* stack buffer */
+ __ntapi->tt_aligned_block_memset(buffer,0,sizeof(buffer));
+
+ status = __ntapi->tt_get_system_directory_dos_path(
+ hsysdir,
+ (wchar16_t *)buffer,
+ sizeof(buffer),
+ base_name,
+ base_name_size,
+ &nt_image_name);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ status = __ntapi->ldr_load_dll(
+ 0,
+ 0,
+ &nt_image_name,
+ image_base);
+
+ return status;
+}
diff --git a/src/ldr/ntapi_ldr_revert_state_to_snapshot.c b/src/ldr/ntapi_ldr_revert_state_to_snapshot.c
new file mode 100644
index 0000000..2ca5087
--- /dev/null
+++ b/src/ldr/ntapi_ldr_revert_state_to_snapshot.c
@@ -0,0 +1,104 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <pemagine/pemagine.h>
+#include <dalist/dalist.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+struct callback_ctx {
+ struct dalist_ex * ldr_state_snapshot;
+ struct pe_ldr_tbl_entry * ldr_tbl_entry;
+ void * image_base;
+ uint32_t load_count;
+ int32_t status;
+};
+
+static int __cdecl __find_next_module_to_unload(
+ struct pe_ldr_tbl_entry * ldr_tbl_entry,
+ enum pe_callback_reason int_callback_reason,
+ void * context)
+{
+ struct dalist_node * node;
+ struct callback_ctx * ctx;
+
+ ctx = (struct callback_ctx *)context;
+
+ if (int_callback_reason == PE_CALLBACK_REASON_ERROR) {
+ ctx->status = NT_STATUS_UNSUCCESSFUL;
+ return ctx->status;
+ } else if (int_callback_reason != PE_CALLBACK_REASON_ITEM) {
+ ctx->status = NT_STATUS_SUCCESS;
+ return 1;
+ } else if (!ldr_tbl_entry->dll_base) {
+ ctx->status = NT_STATUS_SUCCESS;
+ return 1;
+ }
+
+
+ ctx->status = dalist_get_node_by_key(
+ ctx->ldr_state_snapshot,
+ (struct dalist_node_ex **)&node,
+ (uintptr_t)ldr_tbl_entry->dll_base,
+ DALIST_NODE_TYPE_EXISTING,
+ 0);
+
+ if (ctx->status != DALIST_OK)
+ return -1;
+ else if (node)
+ return 1;
+ else if (!ctx->image_base || (ldr_tbl_entry->load_count < ctx->load_count)) {
+ ctx->image_base = ldr_tbl_entry->dll_base;
+ ctx->load_count = ldr_tbl_entry->load_count;
+ ctx->ldr_tbl_entry = ldr_tbl_entry;
+ }
+
+ return 1;
+}
+
+
+int __cdecl __ntapi_ldr_revert_state_to_snapshot(
+ __in struct dalist_ex * ldr_state_snapshot)
+{
+ struct callback_ctx ctx;
+ uint32_t i;
+
+ if (!ldr_state_snapshot->free && !ldr_state_snapshot->memfn_ptr)
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ ctx.ldr_state_snapshot = ldr_state_snapshot;
+ ctx.image_base = (void *)0;
+ ctx.load_count = 0;
+
+ pe_enum_modules_in_load_order(
+ __find_next_module_to_unload,
+ &ctx);
+
+ while ((ctx.image_base) && (ctx.status == NT_STATUS_SUCCESS)) {
+ if (ctx.load_count == 0xffff) {
+ ctx.load_count = 1;
+ ctx.ldr_tbl_entry->load_count = 1;
+ ctx.ldr_tbl_entry->entry_point = (void *)0;
+ ctx.ldr_tbl_entry->flags = 0;
+ }
+
+ for (i=0; i<ctx.load_count; i++)
+ __ntapi->ldr_unload_dll(ctx.image_base);
+
+ __ntapi->zw_unmap_view_of_section(
+ NT_CURRENT_PROCESS_HANDLE,
+ ctx.image_base);
+ ctx.image_base = (void *)0;
+ ctx.load_count = 0;
+
+ pe_enum_modules_in_load_order(
+ __find_next_module_to_unload,
+ &ctx);
+ }
+
+ return ctx.status;
+}
diff --git a/src/object/ntapi_tt_keyed_object_directory.c b/src/object/ntapi_tt_keyed_object_directory.c
new file mode 100644
index 0000000..7f2da40
--- /dev/null
+++ b/src/object/ntapi_tt_keyed_object_directory.c
@@ -0,0 +1,134 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_guid.h>
+#include <ntapi/nt_string.h>
+#include "ntapi_impl.h"
+
+typedef ntapi_zw_open_directory_object objdir_open_fn;
+
+static int32_t __stdcall __tt_create_keyed_object_directory(
+ __out void ** hdir,
+ __in uint32_t desired_access,
+ __in const wchar16_t prefix[6],
+ __in nt_guid * guid,
+ __in uint32_t key,
+ __in objdir_open_fn * openfn)
+{
+ nt_keyed_objdir_name objdir_name = {__NT_BASED_NAMED_OBJECTS};
+ nt_unicode_string name;
+ nt_oa oa;
+ nt_sqos sqos = {
+ sizeof(sqos),
+ NT_SECURITY_IMPERSONATION,
+ NT_SECURITY_TRACKING_DYNAMIC,
+ 1};
+
+ __ntapi->tt_memcpy_utf16(
+ objdir_name.prefix,
+ prefix,
+ sizeof(objdir_name.prefix));
+
+ __ntapi->tt_guid_to_utf16_string(
+ guid,
+ (nt_guid_str_utf16 *)&objdir_name.objdir_guid);
+
+ __ntapi->tt_uint32_to_hex_utf16(
+ key,objdir_name.key);
+
+ objdir_name.backslash = '\\';
+ objdir_name.objdir_guid.uscore_guid = '_';
+ objdir_name.objdir_guid.uscore_key = '_';
+
+ name.strlen = sizeof(objdir_name);
+ name.maxlen = 0;
+ name.buffer = (uint16_t *)&objdir_name;
+
+ oa.len = sizeof(oa);
+ oa.root_dir = 0;
+ oa.obj_name = &name;
+ oa.obj_attr = NT_OBJ_INHERIT;
+ oa.sec_desc = 0;
+ oa.sec_qos = &sqos;
+
+ return openfn(hdir,desired_access,&oa);
+}
+
+
+int32_t __stdcall __ntapi_tt_create_keyed_object_directory_entry(
+ __out void ** hentry,
+ __in uint32_t desired_access,
+ __in void * hdir,
+ __in void * htarget,
+ __in nt_unicode_string * target_name,
+ __in uint32_t key)
+{
+ int32_t status;
+ nt_oa oa;
+ nt_unicode_string name;
+ wchar16_t keystr[8];
+ uintptr_t buffer[2048/sizeof(uintptr_t)];
+ nt_sqos sqos = {
+ sizeof(sqos),
+ NT_SECURITY_IMPERSONATION,
+ NT_SECURITY_TRACKING_DYNAMIC,
+ 1};
+
+ if (!target_name) {
+ if ((status = __ntapi->zw_query_object(
+ htarget,
+ NT_OBJECT_NAME_INFORMATION,
+ buffer,sizeof(buffer),0)))
+ return status;
+ target_name = (nt_unicode_string *)buffer;
+ }
+
+ __ntapi->tt_uint32_to_hex_utf16(key,keystr);
+
+ name.strlen = sizeof(keystr);
+ name.maxlen = 0;
+ name.buffer = keystr;
+
+ oa.len = sizeof(oa);
+ oa.root_dir = hdir;
+ oa.obj_name = &name;
+ oa.obj_attr = 0;
+ oa.sec_desc = 0;
+ oa.sec_qos = &sqos;
+
+ return __ntapi->zw_create_symbolic_link_object(
+ hentry,
+ desired_access,
+ &oa,target_name);
+}
+
+int32_t __stdcall __ntapi_tt_create_keyed_object_directory(
+ __out void ** hdir,
+ __in uint32_t desired_access,
+ __in const wchar16_t prefix[6],
+ __in nt_guid * guid,
+ __in uint32_t key)
+{
+ return __tt_create_keyed_object_directory(
+ hdir,desired_access,
+ prefix,guid,key,
+ __ntapi->zw_create_directory_object);
+}
+
+int32_t __stdcall __ntapi_tt_open_keyed_object_directory(
+ __out void ** hdir,
+ __in uint32_t desired_access,
+ __in const wchar16_t prefix[6],
+ __in nt_guid * guid,
+ __in uint32_t key)
+{
+ return __tt_create_keyed_object_directory(
+ hdir,desired_access,
+ prefix,guid,key,
+ __ntapi->zw_open_directory_object);
+}
diff --git a/src/port/ntapi_port_name_helper.c b/src/port/ntapi_port_name_helper.c
new file mode 100644
index 0000000..3084cf6
--- /dev/null
+++ b/src/port/ntapi_port_name_helper.c
@@ -0,0 +1,167 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_guid.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_string.h>
+#include "ntapi_impl.h"
+
+typedef wchar16_t __port_service_prefix[6];
+
+static const __port_service_prefix __port_service_null = {0};
+static const __port_service_prefix __port_service_prefixes[4][NT_PORT_TYPE_CAP][NT_PORT_SUBTYPE_CAP] = {
+ {{{'s','v','c','a','n','y'}}},
+ {{{'n','t','c','t','t','y'}}},
+ {{{'v','m','o','u','n','t'}}},
+ {{{'d','a','e','m','o','n'}}}};
+
+static const nt_guid __port_guids[NT_PORT_TYPE_CAP][NT_PORT_SUBTYPE_CAP] = {
+ {NT_PORT_GUID_DEFAULT},
+ {NT_PORT_GUID_SUBSYSTEM},
+ {NT_PORT_GUID_VMOUNT},
+ {NT_PORT_GUID_DAEMON}};
+
+int32_t __stdcall __ntapi_tt_port_guid_from_type(
+ __out nt_guid * guid,
+ __in nt_port_type type,
+ __in nt_port_subtype subtype)
+{
+ const nt_guid * src_guid;
+
+ if ((type >= NT_PORT_TYPE_CAP) || (subtype >= NT_PORT_SUBTYPE_CAP))
+ return NT_STATUS_INVALID_PARAMETER;
+
+ src_guid = &(__port_guids[type][subtype]);
+
+ __ntapi->tt_aligned_block_memcpy(
+ (uintptr_t *)guid,
+ (uintptr_t *)src_guid,
+ sizeof(nt_guid));
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+int32_t __stdcall __ntapi_tt_port_type_from_guid(
+ __out nt_port_type * type,
+ __out nt_port_subtype * subtype,
+ __in nt_guid * guid)
+{
+ int itype;
+ int isubtype;
+ const nt_guid * src_guid;
+ uint32_t guid_hash;
+ uint32_t src_hash;
+
+ guid_hash = __ntapi->tt_buffer_crc32(0,guid,sizeof(nt_guid));
+
+ for (itype=0; itype<NT_PORT_TYPE_CAP; itype++) {
+ for (isubtype=0; isubtype<NT_PORT_SUBTYPE_CAP; isubtype++) {
+ src_guid = &(__port_guids[itype][isubtype]);
+ src_hash = __ntapi->tt_buffer_crc32(0,src_guid,sizeof(nt_guid));
+
+ if (guid_hash == src_hash) {
+ *type = (nt_port_type)itype;
+ *subtype = (nt_port_subtype)isubtype;
+
+ return NT_STATUS_SUCCESS;
+ }
+ }
+ }
+
+ return NT_STATUS_INVALID_PARAMETER;
+
+}
+
+
+int32_t __stdcall __ntapi_tt_port_generate_keys(
+ __out nt_port_keys * keys)
+{
+ int32_t status;
+ nt_large_integer systime;
+ nt_luid luid;
+
+ status = __ntapi->zw_query_system_time(&systime);
+ if (status) return status;
+
+ status = __ntapi->zw_allocate_locally_unique_id(&luid);
+ if (status) return status;
+
+ keys->key[0] = pe_get_current_process_id();
+ keys->key[1] = pe_get_current_thread_id();
+ keys->key[2] = systime.ihigh;
+ keys->key[3] = systime.ulow;
+ keys->key[4] = luid.high;
+ keys->key[5] = luid.low;
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+void __stdcall __ntapi_tt_port_format_keys(
+ __in nt_port_keys * keys,
+ __out nt_port_name_keys * name_keys)
+{
+ __ntapi->tt_uint32_to_hex_utf16(keys->key[0],name_keys->key_1st);
+ __ntapi->tt_uint32_to_hex_utf16(keys->key[1],name_keys->key_2nd);
+ __ntapi->tt_uint32_to_hex_utf16(keys->key[2],name_keys->key_3rd);
+ __ntapi->tt_uint32_to_hex_utf16(keys->key[3],name_keys->key_4th);
+ __ntapi->tt_uint32_to_hex_utf16(keys->key[4],name_keys->key_5th);
+ __ntapi->tt_uint32_to_hex_utf16(keys->key[5],name_keys->key_6th);
+
+ return;
+}
+
+
+void __stdcall __ntapi_tt_port_name_from_attributes(
+ __out nt_port_name * name,
+ __in nt_port_attr * attr)
+{
+ wchar16_t bno[] = __NT_BASED_NAMED_OBJECTS;
+
+ /* base named objects */
+ __ntapi->tt_memcpy_utf16(
+ name->base_named_objects,
+ bno,sizeof(bno));
+
+ /* service prefix */
+ if (attr && (attr->type < NT_PORT_TYPE_CAP) && (attr->subtype < NT_PORT_SUBTYPE_CAP))
+ __ntapi->tt_memcpy_utf16(
+ name->svc_prefix,
+ &(__port_service_prefixes[attr->type][attr->subtype][0][0]),
+ sizeof(name->svc_prefix));
+ else
+ __ntapi->tt_memcpy_utf16(
+ name->svc_prefix,
+ __port_service_null,
+ sizeof(name->svc_prefix));
+
+ /* port guid */
+ __ntapi->tt_guid_to_utf16_string(
+ &attr->guid,
+ (nt_guid_str_utf16 *)&name->port_guid);
+
+ /* port name keys */
+ __ntapi_tt_port_format_keys(
+ &attr->keys,
+ &name->port_name_keys);
+
+ /* backslash and underscores */
+ name->backslash = '\\';
+ name->port_guid.uscore_guid = '_';
+ name->port_guid.uscore_keys = '_';
+ name->port_name_keys.uscore_1st = '_';
+ name->port_name_keys.uscore_2nd = '_';
+ name->port_name_keys.uscore_3rd = '_';
+ name->port_name_keys.uscore_4th = '_';
+ name->port_name_keys.uscore_5th = '_';
+
+ /* null termination */
+ name->null_termination = 0;
+
+ return;
+}
diff --git a/src/process/nt32/tt_fork_v1.s b/src/process/nt32/tt_fork_v1.s
new file mode 100644
index 0000000..2e2f01d
--- /dev/null
+++ b/src/process/nt32/tt_fork_v1.s
@@ -0,0 +1,60 @@
+##########################################################
+## ntapi: Native API core library ##
+## Copyright (C) 2013,2014,2015 Z. Gilboa ##
+## Released under GPLv2 and GPLv3; see COPYING.NTAPI. ##
+##########################################################
+
+.section .text
+
+.global ___tt_fork
+.global ___tt_fork_child_entry_point
+.global @__tt_fork_child_entry_point@4
+.global ___tt_fork_child_entry_point_adj
+.global @__tt_fork_child_entry_point_adj@4
+
+___tt_fork:
+___tt_fork_prolog:
+ push %ebp
+ mov %esp, %ebp
+
+___tt_fork_save_regs:
+ push %ecx
+ push %edx
+ push %ebx
+ push %esi
+ push %edi
+
+___tt_fork_impl_call:
+ mov %esp, %ecx
+ mov $0, %edx
+ call @__tt_fork_impl@8
+
+___tt_fork_restore_regs:
+ pop %edi
+ pop %esi
+ pop %ebx
+ pop %edx
+ pop %ecx
+
+___tt_fork_epilog:
+ mov %ebp, %esp
+ pop %ebp
+ ret
+
+___tt_fork_child_entry_point:
+@__tt_fork_child_entry_point@4:
+___tt_fork_child_entry_point_adj:
+@__tt_fork_child_entry_point_adj@4:
+ xor %eax, %eax
+ mov %ecx, %esp
+
+___tt_fork_child_restore_regs:
+ pop %edi
+ pop %esi
+ pop %ebx
+ pop %edx
+ pop %ecx
+
+___tt_fork_child_epilog:
+ pop %ebp
+ ret
diff --git a/src/process/nt32/tt_fork_v1_i386.c b/src/process/nt32/tt_fork_v1_i386.c
new file mode 100644
index 0000000..34b813e
--- /dev/null
+++ b/src/process/nt32/tt_fork_v1_i386.c
@@ -0,0 +1,66 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+
+#if (__COMPILER__ == __MSVC__) && defined(__X86_MODEL)
+
+intptr_t __fastcall __tt_fork_impl(
+ __in uintptr_t saved_regs_stack_pointer,
+ __in uintptr_t stack_adjustment);
+
+int32_t __declspec(naked) __cdecl __tt_fork(void)
+{
+ __asm {
+ push ebp
+ mov ebp, esp
+
+ push ecx
+ push edx
+ push ebx
+ push esi
+ push edi
+
+ mov ecx, esp
+ call __tt_fork_impl
+
+ pop edi
+ pop esi
+ pop ebx
+ pop edx
+ pop ecx
+
+ mov esp, ebp
+ pop ebp
+ ret
+ };
+}
+
+void __declspec(naked) __fastcall __tt_fork_child_entry_point(uintptr_t esp_saved)
+{
+ __asm {
+ xor eax, eax
+ mov esp, ecx
+
+ pop edi
+ pop esi
+ pop ebx
+ pop edx
+ pop ecx
+
+ pop ebp
+ ret
+ };
+}
+
+void __declspec(naked) __fastcall __tt_fork_child_entry_point_adj(uintptr_t esp_saved)
+{
+ __asm {
+ jmp __tt_fork_child_entry_point
+ };
+}
+
+#endif
diff --git a/src/process/nt64/tt_fork_v1.s b/src/process/nt64/tt_fork_v1.s
new file mode 100644
index 0000000..5f09463
--- /dev/null
+++ b/src/process/nt64/tt_fork_v1.s
@@ -0,0 +1,134 @@
+##########################################################
+## ntapi: Native API core library ##
+## Copyright (C) 2013,2014,2015 Z. Gilboa ##
+## Released under GPLv2 and GPLv3; see COPYING.NTAPI. ##
+##########################################################
+
+.section .text
+
+.global __tt_fork_v1
+.global __tt_fork_child_entry_point
+.global __tt_fork_child_entry_point_adj
+
+__tt_fork_v1:
+__tt_fork_save_regs:
+ push %rbp
+ push %rcx
+ push %rdx
+ push %rbx
+ push %rsi
+ push %rdi
+ push %r8
+ push %r9
+ push %r10
+ push %r11
+ push %r12
+ push %r13
+ push %r14
+ push %r15
+
+ sub 0x40,%rsp
+
+ mov %rsp, %rdx
+ and $0xf, %rdx
+ test %rdx, %rdx
+ jne __tt_fork_impl_adj_call
+
+__tt_fork_impl_call:
+ mov %rsp, %rcx
+ call __tt_fork_impl_v1
+
+ add 0x40,%rsp
+
+ pop %r15
+ pop %r14
+ pop %r13
+ pop %r12
+ pop %r11
+ pop %r10
+ pop %r9
+ pop %r8
+ pop %rdi
+ pop %rsi
+ pop %rbx
+ pop %rdx
+ pop %rcx
+ pop %rbp
+
+ ret
+
+__tt_fork_impl_adj_call:
+ push %rdi
+
+ mov %rsp, %rcx
+ call __tt_fork_impl_v1
+
+ pop %rdi
+
+ add 0x40,%rsp
+
+ pop %r15
+ pop %r14
+ pop %r13
+ pop %r12
+ pop %r11
+ pop %r10
+ pop %r9
+ pop %r8
+ pop %rdi
+ pop %rsi
+ pop %rbx
+ pop %rdx
+ pop %rcx
+ pop %rbp
+
+ ret
+
+
+__tt_fork_child_entry_point:
+ xor %rax, %rax
+ mov %rcx, %rsp
+
+ add 0x40,%rsp
+
+ pop %r15
+ pop %r14
+ pop %r13
+ pop %r12
+ pop %r11
+ pop %r10
+ pop %r9
+ pop %r8
+ pop %rdi
+ pop %rsi
+ pop %rbx
+ pop %rdx
+ pop %rcx
+ pop %rbp
+
+ ret
+
+__tt_fork_child_entry_point_adj:
+ xor %rax, %rax
+ mov %rcx, %rsp
+
+ pop %rdi
+
+ add 0x40,%rsp
+
+ pop %r15
+ pop %r14
+ pop %r13
+ pop %r12
+ pop %r11
+ pop %r10
+ pop %r9
+ pop %r8
+ pop %rdi
+ pop %rsi
+ pop %rbx
+ pop %rdx
+ pop %rcx
+ pop %rbp
+
+ ret
diff --git a/src/process/nt64/tt_fork_v1_x86_64.asm b/src/process/nt64/tt_fork_v1_x86_64.asm
new file mode 100644
index 0000000..f79131e
--- /dev/null
+++ b/src/process/nt64/tt_fork_v1_x86_64.asm
@@ -0,0 +1,136 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+TITLE tt_fork_x86_64
+
+.data
+__tt_fork_impl_v1 PROTO C
+
+.code
+__tt_fork_v1 PROC
+ push rbp
+ push rcx
+ push rdx
+ push rbx
+ push rsi
+ push rdi
+ push r8
+ push r9
+ push r10
+ push r11
+ push r12
+ push r13
+ push r14
+ push r15
+
+ sub rsp, 40h
+
+ mov rdx, rsp
+ and rdx, 15
+ test rdx, rdx
+ jne __tt_fork_impl_adj_call
+
+ mov rcx, rsp
+ call __tt_fork_impl_v1
+
+ add rsp, 40h
+
+ pop r15
+ pop r14
+ pop r13
+ pop r12
+ pop r11
+ pop r10
+ pop r9
+ pop r8
+ pop rdi
+ pop rsi
+ pop rbx
+ pop rdx
+ pop rcx
+ pop rbp
+ ret
+__tt_fork_v1 ENDP
+
+__tt_fork_impl_adj_call PROC
+ push rdi
+
+ mov rcx, rsp
+ mov rdx, 1
+ call __tt_fork_impl_v1
+
+ pop rdi
+
+ add rsp, 40h
+
+ pop r15
+ pop r14
+ pop r13
+ pop r12
+ pop r11
+ pop r10
+ pop r9
+ pop r8
+ pop rdi
+ pop rsi
+ pop rbx
+ pop rdx
+ pop rcx
+ pop rbp
+ ret
+__tt_fork_impl_adj_call ENDP
+
+
+__tt_fork_child_entry_point PROC
+ xor rax, rax
+ mov rsp, rcx
+
+ add rsp, 40h
+
+ pop r15
+ pop r14
+ pop r13
+ pop r12
+ pop r11
+ pop r10
+ pop r9
+ pop r8
+ pop rdi
+ pop rsi
+ pop rbx
+ pop rdx
+ pop rcx
+ pop rbp
+ ret
+__tt_fork_child_entry_point ENDP
+
+
+__tt_fork_child_entry_point_adj PROC
+ xor rax, rax
+ mov rsp, rcx
+
+ pop rdi
+
+ add rsp, 40h
+
+ pop r15
+ pop r14
+ pop r13
+ pop r12
+ pop r11
+ pop r10
+ pop r9
+ pop r8
+ pop rdi
+ pop rsi
+ pop rbx
+ pop rdx
+ pop rcx
+ pop rbp
+ ret
+__tt_fork_child_entry_point_adj ENDP
+
+END
diff --git a/src/process/nt64/tt_fork_v2_x86_64.asm b/src/process/nt64/tt_fork_v2_x86_64.asm
new file mode 100644
index 0000000..cc6e353
--- /dev/null
+++ b/src/process/nt64/tt_fork_v2_x86_64.asm
@@ -0,0 +1,50 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+TITLE tt_fork_x86_64
+
+.data
+__tt_fork_impl_v2 PROTO C
+
+.code
+__tt_fork_v2 PROC
+ push rbp
+ push rcx
+ push rdx
+ push rbx
+ push rsi
+ push rdi
+ push r8
+ push r9
+ push r10
+ push r11
+ push r12
+ push r13
+ push r14
+ push r15
+
+ sub rsp, 40h
+ call __tt_fork_impl_v2
+ add rsp, 40h
+
+ pop r15
+ pop r14
+ pop r13
+ pop r12
+ pop r11
+ pop r10
+ pop r9
+ pop r8
+ pop rdi
+ pop rsi
+ pop rbx
+ pop rdx
+ pop rcx
+ pop rbp
+ ret
+__tt_fork_v2 ENDP
+
+END
diff --git a/src/process/ntapi_tt_create_native_process_v1.c b/src/process/ntapi_tt_create_native_process_v1.c
new file mode 100644
index 0000000..b2572cc
--- /dev/null
+++ b/src/process/ntapi_tt_create_native_process_v1.c
@@ -0,0 +1,258 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <pemagine/pemagine.h>
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_thread.h>
+#include <ntapi/nt_process.h>
+#include <ntapi/nt_string.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+static int32_t __tt_create_process_cancel(nt_create_process_params * params, void * hsection, int32_t status)
+{
+ if (params->hprocess) {
+ __ntapi->zw_terminate_process(params->hprocess,NT_STATUS_INTERNAL_ERROR);
+ __ntapi->zw_close(params->hprocess);
+ }
+
+ if (params->hthread)
+ __ntapi->zw_close(params->hthread);
+
+ if (hsection)
+ __ntapi->zw_close(hsection);
+
+ return status;
+}
+
+int32_t __stdcall __ntapi_tt_create_native_process_v1(nt_create_process_params * params)
+{
+ int32_t status;
+ void * hfile;
+ void * hsection;
+
+ nt_object_attributes oa_file;
+ nt_object_attributes oa_process;
+ nt_object_attributes oa_thread;
+
+ nt_unicode_string nt_image;
+ nt_unicode_string nt_cmd_line;
+ nt_process_parameters * rprocess_params;
+ nt_thread_params tparams;
+
+ nt_io_status_block iosb;
+ nt_section_image_information sii;
+
+ wchar16_t * cmd_line_runtime_buffer;
+ size_t cmd_line_runtime_buffer_size;
+ int fresume_thread;
+
+ #if defined (__NT32)
+ wchar16_t runtime_arg[12] = {
+ ' ','-','r',' ',
+ 'i','n','t','e','g','r','a','l'};
+ #elif defined (__NT64)
+ wchar16_t runtime_arg[20] = {
+ ' ','-','r',' ',
+ 'i','n','t','e','g','r','a','l',
+ '-','r','u','n','t','i','m','e'};
+ #endif
+
+ /* validation */
+ if (params->cmd_line && params->process_params)
+ return NT_STATUS_INVALID_PARAMETER_MIX;
+ else if (params->cmd_line && params->rtblock)
+ return NT_STATUS_INVALID_PARAMETER_MIX;
+ else if (params->environment && params->process_params)
+ return NT_STATUS_INVALID_PARAMETER_MIX;
+
+ /* tparams */
+ __ntapi->tt_aligned_block_memset(
+ &tparams, 0, sizeof(tparams));
+
+ /* image_name */
+ __ntapi->rtl_init_unicode_string(
+ &nt_image,
+ params->image_name);
+
+ /* oa_process */
+ if (!params->obj_attr_process) {
+ __ntapi->tt_aligned_block_memset(
+ &oa_process,0,sizeof(oa_process));
+
+ oa_process.len = sizeof(oa_process);
+ params->obj_attr_process = &oa_process;
+ }
+
+ /* oa_thread */
+ if (!params->obj_attr_thread) {
+ __ntapi->tt_aligned_block_memset(
+ &oa_thread,0,sizeof(oa_thread));
+
+ oa_thread.len = sizeof(oa_thread);
+ params->obj_attr_thread = &oa_thread;
+ }
+
+ /* legacy tasks */
+ /* init the oa_file structure */
+ oa_file.len = sizeof(nt_object_attributes);
+ oa_file.root_dir = (void *)0;
+ oa_file.obj_name = &nt_image;
+ oa_file.obj_attr = 0;
+ oa_file.sec_desc = (nt_security_descriptor *)0;
+ oa_file.sec_qos = (nt_sqos *)0;
+
+ /* open the file */
+ if ((status = __ntapi->zw_open_file(
+ &hfile,
+ NT_FILE_EXECUTE | NT_PROCESS_SYNCHRONIZE,
+ &oa_file,
+ &iosb,
+ NT_FILE_SHARE_READ,
+ NT_FILE_SYNCHRONOUS_IO_NONALERT)))
+ return status;
+
+ /* create the executable section */
+ hsection = 0;
+ oa_file.obj_name = 0;
+
+ status = __ntapi->zw_create_section(
+ &hsection,
+ NT_SECTION_ALL_ACCESS,
+ &oa_file,0,
+ NT_PAGE_EXECUTE,
+ NT_SEC_IMAGE,
+ hfile);
+
+ __ntapi->zw_close(hfile);
+ if (status) return status;
+
+ /* create the process */
+ if ((status = __ntapi->zw_create_process(
+ ¶ms->hprocess,
+ NT_PROCESS_ALL_ACCESS,
+ &oa_process,
+ NT_CURRENT_PROCESS_HANDLE,
+ 1,hsection,0,0)))
+ return __tt_create_process_cancel(params,hsection,status);
+
+ /* obtain stack/heap and entry point information */
+ if ((status = __ntapi->zw_query_section(
+ hsection,
+ NT_SECTION_IMAGE_INFORMATION,
+ &sii,sizeof(sii),0)))
+ return __tt_create_process_cancel(params,hsection,status);
+
+ /* obtain process information */
+ if ((status = __ntapi->zw_query_information_process(
+ tparams.hprocess,
+ NT_PROCESS_BASIC_INFORMATION,
+ ¶ms->pbi,sizeof(params->pbi),
+ 0)))
+ return __tt_create_process_cancel(params,hsection,status);
+
+ /* create remote process parameters block */
+ if (!params->process_params) {
+ /* cmd_line */
+ if (!params->cmd_line) {
+ params->cmd_line = params->image_name;
+ }
+
+ __ntapi->rtl_init_unicode_string(
+ &nt_cmd_line,
+ params->cmd_line);
+
+ /* rtblock */
+ if (params->rtblock) {
+ cmd_line_runtime_buffer = (wchar16_t *)0;
+ cmd_line_runtime_buffer_size = nt_cmd_line.maxlen
+ + sizeof(runtime_arg);
+
+ if ((status = __ntapi->zw_allocate_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ (void **)&cmd_line_runtime_buffer,
+ 0,&cmd_line_runtime_buffer_size,
+ NT_MEM_RESERVE | NT_MEM_COMMIT,
+ NT_PAGE_READWRITE)))
+ return __tt_create_process_cancel(params,hsection,status);
+
+ __ntapi->tt_memcpy_utf16(
+ (wchar16_t *)cmd_line_runtime_buffer,
+ (wchar16_t *)nt_cmd_line.buffer,
+ nt_cmd_line.strlen);
+
+ __ntapi->tt_memcpy_utf16(
+ (wchar16_t *)pe_va_from_rva(
+ cmd_line_runtime_buffer,
+ nt_cmd_line.strlen),
+ (wchar16_t *)runtime_arg,
+ sizeof(runtime_arg));
+
+ nt_cmd_line.strlen += sizeof(runtime_arg);
+ nt_cmd_line.maxlen += sizeof(runtime_arg);
+ nt_cmd_line.buffer = cmd_line_runtime_buffer;
+ }
+
+ /* environment */
+ if (!params->environment) {
+ params->environment = __ntapi->tt_get_peb_env_block_utf16();
+ }
+ }
+
+ fresume_thread = (params->creation_flags_thread ^ 0x01) & 0x01;
+
+ /* create target thread */
+ tparams.hprocess = params->hprocess;
+ tparams.start = (nt_thread_start_routine *)sii.entry_point;
+ tparams.obj_attr = &oa_thread;
+ tparams.creation_flags = NT_CREATE_SUSPENDED | NT_CREATE_FIRST_THREAD_OF_PROCESS;
+ tparams.stack_size_commit = sii.stack_commit;
+ tparams.stack_size_reserve = sii.stack_reserve;
+
+ if ((status = __ntapi->tt_create_remote_thread(&tparams)))
+ return __tt_create_process_cancel(params,hsection,status);
+
+ /* remote process params */
+ if ((status = __ntapi->tt_create_remote_process_params(
+ tparams.hprocess,
+ &rprocess_params,
+ &nt_image,
+ (nt_unicode_string *)0,
+ (nt_unicode_string *)0,
+ &nt_cmd_line,
+ params->environment,
+ (nt_unicode_string *)0,
+ (nt_unicode_string *)0,
+ (nt_unicode_string *)0,
+ (nt_unicode_string *)0)))
+ return __tt_create_process_cancel(params,hsection,status);
+
+ /* update the target process environment block: */
+ /* make process_params point to rparams_block */
+ if ((status = __ntapi->zw_write_virtual_memory(
+ tparams.hprocess,
+ (char *)((uintptr_t)params->pbi.peb_base_address
+ + (uintptr_t)&(((nt_peb *)0)->process_params)),
+ (char *)&rprocess_params,
+ sizeof(uintptr_t),0)))
+ return __tt_create_process_cancel(params,hsection,status);
+
+ /* rtdata */
+ if (params->rtblock && (status = __ntapi_tt_create_remote_runtime_data(tparams.hprocess,params->rtblock)))
+ return __tt_create_process_cancel(params,hsection,status);
+
+ if (fresume_thread && (status = __ntapi->zw_resume_thread(tparams.hthread,0)))
+ return __tt_create_process_cancel(params,hsection,status);
+
+ /* all done */
+ params->hthread = tparams.hthread;
+ params->cid.process_id = params->pbi.unique_process_id;
+ params->cid.thread_id = tparams.thread_id;
+
+ return status;
+}
diff --git a/src/process/ntapi_tt_create_native_process_v2.c b/src/process/ntapi_tt_create_native_process_v2.c
new file mode 100644
index 0000000..49fbaf7
--- /dev/null
+++ b/src/process/ntapi_tt_create_native_process_v2.c
@@ -0,0 +1,233 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <pemagine/pemagine.h>
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_thread.h>
+#include <ntapi/nt_process.h>
+#include <ntapi/nt_string.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+static int32_t __tt_create_process_cancel(nt_create_process_params * params, int32_t status)
+{
+ if (params->hprocess) {
+ __ntapi->zw_terminate_process(params->hprocess,NT_STATUS_INTERNAL_ERROR);
+ __ntapi->zw_close(params->hprocess);
+ }
+
+ if (params->hthread)
+ __ntapi->zw_close(params->hthread);
+
+ return status;
+}
+
+
+int32_t __stdcall __ntapi_tt_create_native_process_v2(
+ __in_out nt_create_process_params * params)
+{
+ int32_t status;
+
+ nt_object_attributes oa_process;
+ nt_object_attributes oa_thread;
+
+ nt_unicode_string nt_image;
+ nt_unicode_string nt_cmd_line;
+ wchar16_t * cmd_line_runtime_buffer;
+ size_t cmd_line_runtime_buffer_size;
+
+ nt_create_process_info nt_process_info;
+ int fresume_thread;
+
+ struct {
+ size_t size_in_bytes;
+ nt_create_process_ext_param file_info;
+ } ext_params;
+
+ #if defined (__NT32)
+ wchar16_t runtime_arg[12] = {
+ ' ','-','r',' ',
+ 'i','n','t','e','g','r','a','l'};
+ #elif defined (__NT64)
+ wchar16_t runtime_arg[20] = {
+ ' ','-','r',' ',
+ 'i','n','t','e','g','r','a','l',
+ '-','r','u','n','t','i','m','e'};
+ #endif
+
+ /* validation */
+ if (params->cmd_line && params->process_params)
+ return NT_STATUS_INVALID_PARAMETER_MIX;
+ else if (params->cmd_line && params->rtblock)
+ return NT_STATUS_INVALID_PARAMETER_MIX;
+ else if (params->environment && params->process_params)
+ return NT_STATUS_INVALID_PARAMETER_MIX;
+
+ /* image_name */
+ __ntapi->rtl_init_unicode_string(
+ &nt_image,
+ params->image_name);
+
+ /* oa_process */
+ if (!params->obj_attr_process) {
+ __ntapi->tt_aligned_block_memset(
+ &oa_process,0,sizeof(oa_process));
+
+ oa_process.len = sizeof(oa_process);
+ params->obj_attr_process = &oa_process;
+ }
+
+ /* oa_thread */
+ if (!params->obj_attr_thread) {
+ __ntapi->tt_aligned_block_memset(
+ &oa_thread,0,sizeof(oa_thread));
+
+ oa_thread.len = sizeof(oa_thread);
+ params->obj_attr_thread = &oa_thread;
+ }
+
+ /* process_params */
+ if (!params->process_params) {
+ /* cmd_line */
+ if (!params->cmd_line) {
+ params->cmd_line = params->image_name;
+ }
+
+ __ntapi->rtl_init_unicode_string(
+ &nt_cmd_line,
+ params->cmd_line);
+
+ /* rtdata (alternative to cmd_line) */
+ if (params->rtblock) {
+ cmd_line_runtime_buffer = (wchar16_t *)0;
+ cmd_line_runtime_buffer_size = nt_cmd_line.maxlen
+ + sizeof(runtime_arg);
+
+ if ((status = __ntapi->zw_allocate_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ (void **)&cmd_line_runtime_buffer,
+ 0,&cmd_line_runtime_buffer_size,
+ NT_MEM_RESERVE | NT_MEM_COMMIT,
+ NT_PAGE_READWRITE)))
+ return status;
+
+ __ntapi->tt_memcpy_utf16(
+ (wchar16_t *)cmd_line_runtime_buffer,
+ (wchar16_t *)nt_cmd_line.buffer,
+ nt_cmd_line.strlen);
+
+ __ntapi->tt_memcpy_utf16(
+ (wchar16_t *)pe_va_from_rva(
+ cmd_line_runtime_buffer,
+ nt_cmd_line.strlen),
+ (wchar16_t *)runtime_arg,
+ sizeof(runtime_arg));
+
+ nt_cmd_line.strlen += sizeof(runtime_arg);
+ nt_cmd_line.maxlen += sizeof(runtime_arg);
+ nt_cmd_line.buffer = cmd_line_runtime_buffer;
+ }
+
+
+ /* environment */
+ if (!params->environment)
+ params->environment = __ntapi->tt_get_peb_env_block_utf16();
+
+ if ((status = __ntapi->rtl_create_process_parameters(
+ ¶ms->process_params,
+ &nt_image,
+ (nt_unicode_string *)0,
+ (nt_unicode_string *)0,
+ &nt_cmd_line,
+ params->environment,
+ (nt_unicode_string *)0,
+ (nt_unicode_string *)0,
+ (nt_unicode_string *)0,
+ (nt_unicode_string *)0)))
+ return status;
+
+ __ntapi->rtl_normalize_process_params(params->process_params);
+ }
+
+ /* create_process_info */
+ if (!params->create_process_info) {
+ __ntapi->tt_aligned_block_memset(
+ &nt_process_info,0,sizeof(nt_process_info));
+
+ nt_process_info.size = sizeof(nt_create_process_info);
+ nt_process_info.state = NT_PROCESS_CREATE_INITIAL_STATE;
+ nt_process_info.init_state.init_flags = NT_PROCESS_CREATE_INFO_OBTAIN_OUTPUT;
+ nt_process_info.init_state.file_access_ext = NT_FILE_READ_ATTRIBUTES|NT_FILE_READ_ACCESS;
+
+ params->create_process_info = &nt_process_info;
+ }
+
+ /* create_process_ext_params */
+ if (!params->create_process_ext_params) {
+ __ntapi->tt_aligned_block_memset(
+ &ext_params,0,sizeof(ext_params));
+
+ ext_params.size_in_bytes = sizeof(ext_params);
+
+ /* file_info */
+ ext_params.file_info.ext_param_type = NT_CREATE_PROCESS_EXT_PARAM_SET_FILE_NAME;
+ ext_params.file_info.ext_param_size = nt_image.strlen;
+ ext_params.file_info.ext_param_addr = nt_image.buffer;
+
+ params->create_process_ext_params = (nt_create_process_ext_params *)&ext_params;
+ }
+
+ params->hprocess = 0;
+ params->hthread = 0;
+ fresume_thread = 0;
+
+ if (params->rtblock) {
+ fresume_thread = (params->creation_flags_thread ^ 0x01) & 0x01;
+ params->creation_flags_thread |= 0x01;
+ }
+
+ if (!params->desired_access_process)
+ params->desired_access_process = NT_PROCESS_ALL_ACCESS;
+
+ if (!params->desired_access_thread)
+ params->desired_access_thread = NT_THREAD_ALL_ACCESS;
+
+ if ((status = __ntapi->zw_create_user_process(
+ ¶ms->hprocess,
+ ¶ms->hthread,
+ params->desired_access_process,
+ params->desired_access_thread,
+ params->obj_attr_process,
+ params->obj_attr_thread,
+ params->creation_flags_process,
+ params->creation_flags_thread,
+ params->process_params,
+ params->create_process_info,
+ params->create_process_ext_params)))
+ return status;
+
+ if ((status = __ntapi->zw_query_information_process(
+ params->hprocess,
+ NT_PROCESS_BASIC_INFORMATION,
+ ¶ms->pbi,sizeof(params->pbi),
+ 0)))
+ return __tt_create_process_cancel(params,status);
+
+ if (!params->rtblock)
+ return NT_STATUS_SUCCESS;
+
+ /* rtdata */
+ if ((status = __ntapi_tt_create_remote_runtime_data(params->hprocess,params->rtblock)))
+ return __tt_create_process_cancel(params,status);
+
+ /* conditional resume */
+ if (fresume_thread && (status = __ntapi->zw_resume_thread(params->hthread,0)))
+ return __tt_create_process_cancel(params,status);
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/process/ntapi_tt_create_remote_process_params.c b/src/process/ntapi_tt_create_remote_process_params.c
new file mode 100644
index 0000000..3ff8711
--- /dev/null
+++ b/src/process/ntapi_tt_create_remote_process_params.c
@@ -0,0 +1,331 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <pemagine/pemagine.h>
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_thread.h>
+#include <ntapi/nt_process.h>
+#include <ntapi/nt_string.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tt_create_remote_process_params(
+ __in void * hprocess,
+ __out nt_process_parameters ** rprocess_params,
+ __in nt_unicode_string * image_file,
+ __in nt_unicode_string * dll_path __optional,
+ __in nt_unicode_string * current_directory __optional,
+ __in nt_unicode_string * command_line __optional,
+ __in wchar16_t * environment __optional,
+ __in nt_unicode_string * window_title __optional,
+ __in nt_unicode_string * desktop_info __optional,
+ __in nt_unicode_string * shell_info __optional,
+ __in nt_unicode_string * runtime_data __optional)
+{
+ #define __ALIGN_ALLOC_SIZE \
+ process_params.alloc_size += sizeof(uintptr_t) - 1; \
+ process_params.alloc_size /= sizeof(uintptr_t); \
+ process_params.alloc_size *= sizeof(uintptr_t);
+
+ int32_t status;
+
+ ptrdiff_t d_image;
+ ptrdiff_t d_dll_path;
+ ptrdiff_t d_cwd;
+ ptrdiff_t d_cmd_line;
+ ptrdiff_t d_environment;
+ ptrdiff_t d_runtime;
+ /*
+ ptrdiff_t d_wnd_title;
+ ptrdiff_t d_desktop;
+ ptrdiff_t d_shell;
+ */
+
+ wchar16_t * wch;
+ size_t env_block_size;
+ size_t params_block_size;
+ size_t bytes_written;
+
+ nt_process_parameters process_params;
+ nt_process_parameters * params_block;
+ nt_process_parameters * rparams_block;
+ nt_process_parameters * params_default;
+
+ /* make the compiler happy */
+ d_image = 0;
+ d_dll_path = 0;
+ d_cwd = 0;
+ d_cmd_line = 0;
+ d_environment = 0;
+ d_runtime = 0;
+ env_block_size = 0;
+
+ /* initialize */
+ __ntapi->tt_aligned_block_memset(
+ &process_params,
+ 0,sizeof(nt_process_parameters));
+
+ /* allow for extended structures (newer OS versions) */
+ process_params.alloc_size = sizeof(nt_process_parameters)
+ + 8 * sizeof(uintptr_t);
+
+ params_default = ((nt_peb *)pe_get_peb_address())->process_params;
+
+ /* image_file */
+ if (image_file) {
+ /* check alignment and sanity */
+ if ((uintptr_t)image_file->buffer % sizeof(uintptr_t))
+ return NT_STATUS_INVALID_PARAMETER_2;
+ else if (image_file->maxlen < image_file->strlen)
+ return NT_STATUS_INVALID_PARAMETER_2;
+
+ process_params.image_file_name.strlen = image_file->strlen;
+ process_params.image_file_name.maxlen = image_file->maxlen;
+
+ /* store offset and update alloc_size */
+ d_image = process_params.alloc_size;
+ process_params.alloc_size += image_file->maxlen;
+ __ALIGN_ALLOC_SIZE;
+ }
+
+ /* dll_path */
+ if (!dll_path)
+ dll_path = &(params_default->dll_path);
+
+ if (dll_path) {
+ /* check alignment and sanity */
+ if ((uintptr_t)dll_path->buffer % sizeof(uintptr_t))
+ return NT_STATUS_INVALID_PARAMETER_3;
+ else if (dll_path->maxlen < dll_path->strlen)
+ return NT_STATUS_INVALID_PARAMETER_3;
+
+ process_params.dll_path.strlen = dll_path->strlen;
+ process_params.dll_path.maxlen = dll_path->maxlen;
+
+ /* store offset and update alloc_size */
+ d_dll_path = process_params.alloc_size;
+ process_params.alloc_size += dll_path->maxlen;
+ __ALIGN_ALLOC_SIZE;
+ }
+
+ /* current_directory */
+ if (!current_directory)
+ current_directory = &(params_default->cwd_name);
+
+ if (current_directory) {
+ /* check alignment and sanity */
+ if ((uintptr_t)current_directory->buffer % sizeof(uintptr_t))
+ return NT_STATUS_INVALID_PARAMETER_4;
+ else if (current_directory->maxlen < current_directory->strlen)
+ return NT_STATUS_INVALID_PARAMETER_4;
+
+ process_params.cwd_name.strlen = current_directory->strlen;
+ process_params.cwd_name.maxlen = current_directory->maxlen;
+
+ /* store offset and update alloc_size */
+ d_cwd = process_params.alloc_size;
+ process_params.alloc_size += current_directory->maxlen;
+ __ALIGN_ALLOC_SIZE;
+ }
+
+ /* command_line */
+ if (command_line) {
+ /* check alignment and sanity */
+ if ((uintptr_t)command_line->buffer % sizeof(uintptr_t))
+ return NT_STATUS_INVALID_PARAMETER_5;
+ else if (command_line->maxlen < command_line->strlen)
+ return NT_STATUS_INVALID_PARAMETER_5;
+
+ process_params.command_line.strlen = command_line->strlen;
+ process_params.command_line.maxlen = command_line->maxlen;
+
+ /* store offset and update alloc_size */
+ d_cmd_line = process_params.alloc_size;
+ process_params.alloc_size += command_line->maxlen;
+ __ALIGN_ALLOC_SIZE;
+ }
+
+ /* environment */
+ if (environment) {
+ /* check alignment */
+ if ((uintptr_t)environment % sizeof(uintptr_t))
+ return NT_STATUS_INVALID_PARAMETER_6;
+
+ /* obtain size of environment block */
+ wch = environment;
+
+ while (*wch) {
+ /* reach the end of the current variable */
+ while (*wch++)
+ /* proceed to the next variable */
+ wch++;
+ }
+
+ env_block_size = (uintptr_t)wch - (uintptr_t)environment;
+
+ /* store offset and update alloc_size */
+ d_environment = process_params.alloc_size;
+ process_params.alloc_size += (uint32_t)env_block_size + 0x1000;
+ __ALIGN_ALLOC_SIZE;
+ }
+
+ /* runtime_data */
+ if (runtime_data) {
+ /* check alignment and sanity */
+ if ((uintptr_t)runtime_data->buffer % sizeof(uintptr_t))
+ return NT_STATUS_INVALID_PARAMETER_5;
+ else if (runtime_data->maxlen < runtime_data->strlen)
+ return NT_STATUS_INVALID_PARAMETER_5;
+
+ process_params.runtime_data.strlen = runtime_data->strlen;
+ process_params.runtime_data.maxlen = runtime_data->maxlen;
+
+ /* store offset and update alloc_size */
+ d_runtime = process_params.alloc_size;
+ process_params.alloc_size += runtime_data->maxlen;
+ __ALIGN_ALLOC_SIZE;
+ }
+
+ /* allocate local and remote process parameters blocks */
+ params_block = (nt_process_parameters *)0;
+ rparams_block = (nt_process_parameters *)0;
+
+ process_params.used_size = process_params.alloc_size;
+ params_block_size = process_params.alloc_size;
+
+ /* local block */
+ status = __ntapi->zw_allocate_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ (void **)¶ms_block,
+ 0,
+ ¶ms_block_size,
+ NT_MEM_COMMIT,
+ NT_PAGE_READWRITE);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ process_params.alloc_size = (uint32_t)params_block_size;
+ __ntapi->tt_aligned_block_memset(params_block,0,params_block_size);
+
+ /* remote block */
+ status = __ntapi->zw_allocate_virtual_memory(
+ hprocess,
+ (void **)&rparams_block,
+ 0,
+ ¶ms_block_size,
+ NT_MEM_RESERVE | NT_MEM_COMMIT,
+ NT_PAGE_READWRITE);
+
+ if (status != NT_STATUS_SUCCESS) {
+ __ntapi->zw_free_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ (void **)¶ms_block,
+ (size_t *)&process_params.alloc_size,
+ NT_MEM_RELEASE);
+
+ return status;
+ }
+
+ /* copy the process_params structure */
+ __ntapi->tt_aligned_memcpy_utf16(
+ (uintptr_t *)params_block,
+ (uintptr_t *)&process_params,
+ sizeof(nt_process_parameters));
+
+ /* image_file */
+ if (image_file) {
+ params_block->image_file_name.buffer =
+ (uint16_t *)pe_va_from_rva(rparams_block,d_image);
+
+ __ntapi->tt_aligned_memcpy_utf16(
+ (uintptr_t *)pe_va_from_rva(params_block,d_image),
+ (uintptr_t *)image_file->buffer,
+ image_file->strlen);
+ }
+
+ /* dll_path */
+ if (dll_path) {
+ params_block->dll_path.buffer =
+ (uint16_t *)pe_va_from_rva(rparams_block,d_dll_path);
+
+ __ntapi->tt_aligned_memcpy_utf16(
+ (uintptr_t *)pe_va_from_rva(params_block,d_dll_path),
+ (uintptr_t *)dll_path->buffer,
+ dll_path->strlen);
+ }
+
+ /* current_directory */
+ if (current_directory) {
+ params_block->cwd_name.buffer =
+ (uint16_t *)pe_va_from_rva(rparams_block,d_cwd);
+
+ __ntapi->tt_aligned_memcpy_utf16(
+ (uintptr_t *)pe_va_from_rva(params_block,d_cwd),
+ (uintptr_t *)current_directory->buffer,
+ current_directory->strlen);
+ }
+
+ /* command_line */
+ if (command_line) {
+ params_block->command_line.buffer =
+ (uint16_t *)pe_va_from_rva(rparams_block,d_cmd_line);
+
+ __ntapi->tt_aligned_memcpy_utf16(
+ (uintptr_t *)pe_va_from_rva(params_block,d_cmd_line),
+ (uintptr_t *)command_line->buffer,
+ command_line->strlen);
+ }
+
+ /* environment */
+ if (environment) {
+ params_block->environment =
+ (wchar16_t *)pe_va_from_rva(rparams_block,d_environment);
+
+ __ntapi->tt_aligned_memcpy_utf16(
+ (uintptr_t *)pe_va_from_rva(params_block,d_environment),
+ (uintptr_t *)environment,
+ env_block_size);
+ }
+
+ /* runtime_data */
+ if (runtime_data) {
+ params_block->runtime_data.buffer =
+ (uint16_t *)pe_va_from_rva(rparams_block,d_runtime);
+
+ __ntapi->tt_aligned_memcpy_utf16(
+ (uintptr_t *)pe_va_from_rva(params_block,d_runtime),
+ (uintptr_t *)runtime_data->buffer,
+ runtime_data->strlen);
+ }
+
+ params_block->flags = 1; /* normalized */
+
+ /* copy the local params block to the remote process */
+ status = __ntapi->zw_write_virtual_memory(
+ hprocess,
+ rparams_block,
+ (char *)params_block,
+ process_params.alloc_size,
+ &bytes_written);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ /* free the local params block */
+ __ntapi->zw_free_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ (void **)¶ms_block,
+ (size_t *)&process_params.alloc_size,
+ NT_MEM_RELEASE);
+
+ /* all done */
+ *rprocess_params = rparams_block;
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/process/ntapi_tt_create_remote_runtime_data.c b/src/process/ntapi_tt_create_remote_runtime_data.c
new file mode 100644
index 0000000..d3cf9ca
--- /dev/null
+++ b/src/process/ntapi_tt_create_remote_runtime_data.c
@@ -0,0 +1,178 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_memory.h>
+#include <ntapi/nt_process.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+typedef struct _nt_process_basic_information nt_pbi;
+
+int32_t __stdcall __ntapi_tt_create_remote_runtime_data(
+ __in void * hprocess,
+ __in_out nt_runtime_data_block * rtblock)
+{
+ int32_t status;
+
+ size_t bytes_written;
+ nt_pbi rpbi;
+ nt_process_parameters * rprocess_params;
+ nt_unicode_string rcmd_line;
+ uint32_t runtime_arg_hash;
+ nt_runtime_data * rtdata;
+ void * srv_ready;
+
+ #if defined (__NT32)
+ wchar16_t runtime_arg[8] = {
+ 'i','n','t','e','g','r','a','l'};
+ #elif defined (__NT64)
+ wchar16_t runtime_arg[16] = {
+ 'i','n','t','e','g','r','a','l',
+ '-','r','u','n','t','i','m','e'};
+ #endif
+
+ /* validation */
+ if (!hprocess)
+ return NT_STATUS_INVALID_PARAMETER_1;
+ else if (!rtblock)
+ return NT_STATUS_INVALID_PARAMETER_2;
+ else if (!rtblock->addr)
+ return NT_STATUS_INVALID_PARAMETER_2;
+ else if (!rtblock->size)
+ return NT_STATUS_INVALID_PARAMETER_2;
+
+ runtime_arg_hash = __ntapi->tt_buffer_crc32(
+ 0,
+ (char *)runtime_arg,
+ sizeof(runtime_arg));
+
+ /* obtain process information */
+ status = __ntapi->zw_query_information_process(
+ hprocess,
+ NT_PROCESS_BASIC_INFORMATION,
+ (void *)&rpbi,
+ sizeof(nt_process_basic_information),
+ 0);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ status = __ntapi->zw_read_virtual_memory(
+ hprocess,
+ pe_va_from_rva(
+ rpbi.peb_base_address,
+ (uintptr_t)&(((nt_peb *)0)->process_params)),
+ (char *)&rprocess_params,
+ sizeof(uintptr_t),
+ &bytes_written);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ status = __ntapi->zw_read_virtual_memory(
+ hprocess,
+ &rprocess_params->command_line,
+ (char *)&rcmd_line,
+ sizeof(nt_unicode_string),
+ &bytes_written);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ if (rcmd_line.buffer == 0)
+ return NT_STATUS_BUFFER_TOO_SMALL;
+ else if (rcmd_line.strlen < sizeof(runtime_arg) + 4*sizeof(wchar16_t))
+ return NT_STATUS_INVALID_USER_BUFFER;
+
+ status = __ntapi->zw_read_virtual_memory(
+ hprocess,
+ pe_va_from_rva(
+ rcmd_line.buffer,
+ rcmd_line.strlen - sizeof(runtime_arg)),
+ (char *)&runtime_arg,
+ sizeof(runtime_arg),
+ &bytes_written);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ /* verify remote process compatibility */
+ runtime_arg_hash ^= __ntapi->tt_buffer_crc32(
+ 0,
+ (char *)runtime_arg,
+ sizeof(runtime_arg));
+
+ if (runtime_arg_hash)
+ return NT_STATUS_INVALID_SIGNATURE;
+
+ /* remote block */
+ rtblock->remote_size = rtblock->size;
+ status = __ntapi->zw_allocate_virtual_memory(
+ hprocess,
+ &rtblock->remote_addr,
+ 0,
+ &rtblock->remote_size,
+ NT_MEM_RESERVE | NT_MEM_COMMIT,
+ NT_PAGE_READWRITE);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ /* session handles */
+ if (rtblock->flags & NT_RUNTIME_DATA_DUPLICATE_SESSION_HANDLES) {
+ rtdata = (nt_runtime_data *)rtblock->addr;
+ srv_ready = rtdata->srv_ready;
+
+ status = __ntapi->zw_duplicate_object(
+ NT_CURRENT_PROCESS_HANDLE,
+ srv_ready,
+ hprocess,
+ &rtdata->srv_ready,
+ 0,0,NT_DUPLICATE_SAME_ATTRIBUTES | NT_DUPLICATE_SAME_ACCESS);
+ if (status) return status;
+ } else
+ srv_ready = 0;
+
+ /* copy local block to remote process */
+ status = __ntapi->zw_write_virtual_memory(
+ hprocess,
+ rtblock->remote_addr,
+ (char *)rtblock->addr,
+ rtblock->size,
+ &bytes_written);
+
+ /* restore rtdata */
+ if (srv_ready)
+ rtdata->srv_ready = srv_ready;
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ /* runtime_arg */
+ __ntapi->tt_uintptr_to_hex_utf16(
+ (uintptr_t)rtblock->remote_addr,
+ runtime_arg);
+
+ /* update remote runtime arg */
+ status = __ntapi->zw_write_virtual_memory(
+ hprocess,
+ pe_va_from_rva(
+ rcmd_line.buffer,
+ rcmd_line.strlen - sizeof(runtime_arg)),
+ (char *)&runtime_arg,
+ sizeof(runtime_arg),
+ &bytes_written);
+
+ if (status)
+ __ntapi->zw_free_virtual_memory(
+ hprocess,
+ &rtblock->remote_addr,
+ &rtblock->remote_size,
+ NT_MEM_RELEASE);
+
+ return status;
+}
diff --git a/src/process/ntapi_tt_fork_v1.c b/src/process/ntapi_tt_fork_v1.c
new file mode 100644
index 0000000..de917ef
--- /dev/null
+++ b/src/process/ntapi_tt_fork_v1.c
@@ -0,0 +1,218 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_atomic.h>
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_memory.h>
+#include <ntapi/nt_thread.h>
+#include <ntapi/nt_process.h>
+#include <ntapi/nt_string.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+intptr_t __cdecl __attr_hidden__ __tt_fork_v1(void);
+uint32_t __fastcall __attr_hidden__ __tt_fork_child_entry_point(uintptr_t saved_regs_stack_pointer);
+uint32_t __fastcall __attr_hidden__ __tt_fork_child_entry_point_adj(uintptr_t saved_regs_stack_pointer);
+
+/** legacy fork chronology:
+ *
+ * parent:
+ * __ntapi_tt_fork ->
+ * __tt_fork ->
+ * __tt_fork_impl ->
+ * return to __tt_fork -->
+ * __ntapi_tt_fork
+ * -> return to caller
+ *
+ * child:
+ * __tt_fork_child_entry_point[_adj] ->
+ * __ntapi_tt_fork (internal return) ->
+ * -> return to caller
+**/
+
+
+static intptr_t __tt_fork_cancel(void * hprocess,int32_t status)
+{
+ __ntapi->zw_terminate_process(hprocess, status);
+ __ntapi->zw_close(hprocess);
+ return (intptr_t)(-1);
+}
+
+intptr_t __fastcall __tt_fork_impl_v1(
+ uintptr_t saved_regs_stack_pointer,
+ uintptr_t stack_adjustment)
+{
+ int32_t status;
+ void * hprocess;
+ void * hthread;
+ void ** hport_session;
+ ntapi_internals * __internals;
+
+ nt_object_attributes oa;
+ nt_process_basic_information pbi;
+ nt_thread_context context;
+ nt_user_stack stack;
+ nt_memory_basic_information mbi;
+ nt_client_id cid;
+ nt_large_integer timeout;
+
+ hprocess = hthread = (void *)0;
+
+ oa.len = sizeof(nt_object_attributes);
+ oa.root_dir = 0;
+ oa.obj_name = 0;
+ oa.obj_attr = 0;
+ oa.sec_desc = 0;
+ oa.sec_qos = 0;
+
+ if ((status = __ntapi->zw_create_process(
+ &hprocess,
+ NT_PROCESS_ALL_ACCESS,
+ &oa,
+ NT_CURRENT_PROCESS_HANDLE,
+ 1,0,0,0)))
+ return (intptr_t)(-1);
+
+ if ((status = __ntapi->zw_query_information_process(
+ hprocess,
+ NT_PROCESS_BASIC_INFORMATION,
+ (void *)&pbi,
+ sizeof(nt_process_basic_information),
+ 0)))
+ return __tt_fork_cancel(hprocess,status);
+
+
+
+ __ntapi->tt_aligned_block_memset(
+ &context,0,sizeof(nt_thread_context));
+
+ __INIT_CONTEXT(context);
+ context.STACK_POINTER_REGISTER = saved_regs_stack_pointer;
+ context.FAST_CALL_ARG0 = saved_regs_stack_pointer;
+
+ context.INSTRUCTION_POINTER_REGISTER = stack_adjustment
+ ? (uintptr_t)__tt_fork_child_entry_point_adj
+ : (uintptr_t)__tt_fork_child_entry_point;
+
+
+
+ if ((status = __ntapi->zw_query_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ (void *)context.STACK_POINTER_REGISTER,
+ NT_MEMORY_BASIC_INFORMATION,
+ &mbi,sizeof(nt_memory_basic_information),0)))
+ return __tt_fork_cancel(hprocess,status);
+
+ stack.fixed_stack_base = (void *)0;
+ stack.fixed_stack_limit = (void *)0;
+ stack.expandable_stack_base = (void *)((uintptr_t)mbi.base_address + mbi.region_size);
+ stack.expandable_stack_limit = (void *)mbi.base_address;
+ stack.expandable_stack_bottom = (void *)mbi.allocation_base;
+
+
+
+ __internals = __ntapi_internals();
+ hport_session = &__internals->hport_tty_session;
+ timeout.quad = (-1) * 10 * 1000 * __NT_FORK_CHILD_WAIT_MILLISEC;
+
+ if (hport_session && *hport_session)
+ if ((status = __ntapi->tty_client_process_register(
+ *hport_session,
+ pbi.unique_process_id,
+ 0, 0, &timeout)))
+ return __tt_fork_cancel(hprocess,status);
+
+
+ if ((status = __ntapi->zw_create_thread(
+ &hthread,
+ NT_THREAD_ALL_ACCESS,
+ &oa,hprocess,&cid,
+ &context,&stack,0)))
+ return __tt_fork_cancel(hprocess,status);
+
+
+ if (cid.process_id > 0) {
+ __internals->hany[0] = hprocess;
+ __internals->hany[1] = hthread;
+ } else {
+ __internals->hany[0] = 0;
+ __internals->hany[1] = 0;
+ }
+
+ /* hoppla */
+ return (int32_t)cid.process_id;
+}
+
+intptr_t __fastcall __ntapi_tt_fork_v1(
+ __out void ** hprocess,
+ __out void ** hthread)
+{
+ int32_t status;
+ intptr_t pid;
+ nt_large_integer timeout;
+ void ** hport_session;
+ void * hevent_tty_connected;
+ ntapi_internals * __internals;
+
+ __internals = __ntapi_internals();
+ hport_session = &__internals->hport_tty_session;
+ timeout.quad = (-1) * 10 * 1000 * __NT_FORK_CHILD_WAIT_MILLISEC;
+
+ if (at_locked_cas(&__internals->hlock,0,1))
+ return (intptr_t)(-1);
+
+ if (hport_session && *hport_session)
+ if (__ntapi_tt_create_inheritable_event(
+ &hevent_tty_connected,
+ NT_NOTIFICATION_EVENT,
+ NT_EVENT_NOT_SIGNALED))
+ return (intptr_t)(-1);
+
+ pid = __tt_fork_v1();
+
+ *hprocess = __internals->hany[0];
+ *hthread = __internals->hany[1];
+
+ at_store(&__internals->hlock,0);
+
+ if (hport_session && *hport_session) {
+ if (pid == 0) {
+ if ((status = __ntapi->tty_connect(
+ hport_session,
+ __internals->subsystem->base_named_objects,
+ NT_SECURITY_IMPERSONATION)))
+ return __tt_fork_cancel(NT_CURRENT_PROCESS_HANDLE,status);
+
+ __internals->hdev_mount_point_mgr = 0;
+
+ if (__internals->rtdata)
+ __internals->rtdata->hsession = *hport_session;
+
+ __ntapi->zw_set_event(
+ hevent_tty_connected,
+ 0);
+
+ } else if (pid > 0) {
+ status = __ntapi->zw_wait_for_single_object(
+ hevent_tty_connected,
+ NT_SYNC_NON_ALERTABLE,
+ &timeout);
+
+ if (status && __PSX_DEBUG)
+ if ((status = __ntapi->zw_wait_for_single_object(
+ hevent_tty_connected,
+ NT_SYNC_NON_ALERTABLE,
+ 0)))
+ pid = __tt_fork_cancel(*hprocess,status);
+ }
+
+ __ntapi->zw_close(hevent_tty_connected);
+ }
+
+ return pid;
+}
diff --git a/src/process/ntapi_tt_fork_v2.c b/src/process/ntapi_tt_fork_v2.c
new file mode 100644
index 0000000..e483554
--- /dev/null
+++ b/src/process/ntapi_tt_fork_v2.c
@@ -0,0 +1,183 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_memory.h>
+#include <ntapi/nt_thread.h>
+#include <ntapi/nt_process.h>
+#include <ntapi/nt_sync.h>
+#include <ntapi/nt_string.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+static intptr_t __tt_fork_cancel(void * hprocess,int32_t status)
+{
+ __ntapi->zw_terminate_process(hprocess, status);
+ __ntapi->zw_close(hprocess);
+ return (intptr_t)(-1);
+}
+
+intptr_t __fastcall __tt_fork_impl_v2(
+ __out void ** hprocess,
+ __out void ** hthread)
+{
+ int32_t status;
+ void ** hport_session;
+ nt_object_attributes oa_process;
+ nt_object_attributes oa_thread;
+ nt_create_process_info process_info;
+ nt_cid cid;
+ nt_sec_img_inf sec_img_inf;
+ nt_timeout timeout;
+ ntapi_internals * __internals;
+
+ struct {
+ size_t size_in_bytes;
+ nt_create_process_ext_param process_info;
+ nt_create_process_ext_param section_info;
+ } ext_params;
+
+
+ oa_process.len = sizeof(nt_object_attributes);
+ oa_process.root_dir = 0;
+ oa_process.obj_name = 0;
+ oa_process.obj_attr = 0;
+ oa_process.sec_desc = 0;
+ oa_process.sec_qos = 0;
+
+ oa_thread.len = sizeof(nt_object_attributes);
+ oa_thread.root_dir = 0;
+ oa_thread.obj_name = 0;
+ oa_thread.obj_attr = 0;
+ oa_thread.sec_desc = 0;
+ oa_thread.sec_qos = 0;
+
+
+ __ntapi->tt_aligned_block_memset(
+ &process_info,0,sizeof(process_info));
+
+ process_info.size = sizeof(process_info);
+ process_info.state = NT_PROCESS_CREATE_INITIAL_STATE;
+ process_info.init_state.init_flags = NT_PROCESS_CREATE_FLAGS_NO_OBJECT_SYNC;
+
+ __ntapi->tt_aligned_block_memset(&ext_params,0,sizeof(ext_params));
+ __ntapi->tt_aligned_block_memset(&cid,0,sizeof(cid));
+ __ntapi->tt_aligned_block_memset(&sec_img_inf,0,sizeof(sec_img_inf));
+ ext_params.size_in_bytes = sizeof(ext_params);
+
+ ext_params.process_info.ext_param_type = NT_CREATE_PROCESS_EXT_PARAM_GET_CLIENT_ID;
+ ext_params.process_info.ext_param_size = sizeof(cid);
+ ext_params.process_info.ext_param_addr = &cid;
+
+ ext_params.section_info.ext_param_type = NT_CREATE_PROCESS_EXT_PARAM_GET_SECTION_IMAGE_INFO;
+ ext_params.section_info.ext_param_size = sizeof(sec_img_inf);
+ ext_params.section_info.ext_param_addr = &sec_img_inf;
+
+
+ /* [thou shalt remember the single step paradox] */
+ status = __ntapi->zw_create_user_process(
+ hprocess,
+ hthread,
+ NT_PROCESS_ALL_ACCESS,
+ NT_THREAD_ALL_ACCESS,
+ &oa_process,
+ &oa_thread,
+ NT_PROCESS_CREATE_FLAGS_INHERIT_HANDLES,
+ NT_PROCESS_CREATE_FLAGS_CREATE_THREAD_SUSPENDED,
+ (nt_process_parameters *)0,
+ &process_info,
+ (nt_create_process_ext_params *)&ext_params);
+
+ if (status == NT_STATUS_PROCESS_CLONED)
+ return 0;
+ else if (status)
+ return (intptr_t)(-1);
+
+ __internals = __ntapi_internals();
+ hport_session = &__internals->hport_tty_session;
+ timeout.quad = (-1) * 10 * 1000 * __NT_FORK_CHILD_WAIT_MILLISEC;
+
+ if (hport_session && *hport_session)
+ if ((status = __ntapi->tty_client_process_register(
+ *hport_session,
+ cid.process_id,
+ 0,0,&timeout)))
+ return __tt_fork_cancel(*hprocess,status);
+
+ /* [thou shalt remember the single step paradox] */
+ if ((status = __ntapi->zw_resume_thread(
+ *hthread,0)))
+ return __tt_fork_cancel(*hprocess,status);
+
+ /* hoppla */
+ return (int32_t)cid.process_id;
+}
+
+intptr_t __fastcall __ntapi_tt_fork_v2(
+ __out void ** hprocess,
+ __out void ** hthread)
+{
+ int32_t status;
+ intptr_t pid;
+ nt_large_integer timeout;
+ void ** hport_session;
+ void * hevent_tty_connected;
+ ntapi_internals * __internals;
+
+ __internals = __ntapi_internals();
+ hport_session = &__internals->hport_tty_session;
+ timeout.quad = (-1) * 10 * 1000 * __NT_FORK_CHILD_WAIT_MILLISEC;
+
+ if (hport_session && *hport_session)
+ if (__ntapi_tt_create_inheritable_event(
+ &hevent_tty_connected,
+ NT_NOTIFICATION_EVENT,
+ NT_EVENT_NOT_SIGNALED))
+ return (intptr_t)(-1);
+
+ pid = __tt_fork_impl_v2(hprocess,hthread);
+
+ if (!hport_session || !*hport_session)
+ return pid;
+ else if (pid < 0)
+ return pid;
+
+ if (pid == 0) {
+ if ((status = __ntapi->tty_connect(
+ hport_session,
+ __internals->subsystem->base_named_objects,
+ NT_SECURITY_IMPERSONATION)))
+ return __tt_fork_cancel(NT_CURRENT_PROCESS_HANDLE,status);
+
+ __internals->hdev_mount_point_mgr = 0;
+
+ if (__internals->rtdata)
+ __internals->rtdata->hsession = *hport_session;
+
+ __ntapi->zw_set_event(
+ hevent_tty_connected,
+ 0);
+ } else {
+ status = __ntapi->zw_wait_for_single_object(
+ hevent_tty_connected,
+ NT_SYNC_NON_ALERTABLE,
+ &timeout);
+
+ if (status && __PSX_DEBUG)
+ if ((status = __ntapi->zw_wait_for_single_object(
+ hevent_tty_connected,
+ NT_SYNC_NON_ALERTABLE,
+ 0)))
+ pid = __tt_fork_cancel(*hprocess,status);
+ }
+
+
+ __ntapi->zw_close(hevent_tty_connected);
+
+ return pid;
+}
diff --git a/src/process/ntapi_tt_get_runtime_data.c b/src/process/ntapi_tt_get_runtime_data.c
new file mode 100644
index 0000000..92b4b2b
--- /dev/null
+++ b/src/process/ntapi_tt_get_runtime_data.c
@@ -0,0 +1,83 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_memory.h>
+#include <ntapi/nt_process.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+#if defined (__NT32)
+static wchar16_t runtime_arg[12] = {
+ ' ','-','r',' ',
+ 'i','n','t','e','g','r','a','l'};
+#elif defined (__NT64)
+static wchar16_t runtime_arg[20] = {
+ ' ','-','r',' ',
+ 'i','n','t','e','g','r','a','l',
+ '-','r','u','n','t','i','m','e'};
+#endif
+
+int32_t __stdcall __ntapi_tt_get_runtime_data(
+ __out nt_runtime_data ** rtdata,
+ __in wchar16_t ** argv)
+{
+ int32_t status;
+ nt_process_parameters * process_params;
+ nt_cmd_option_meta_utf16 cmd_opt_meta;
+ nt_runtime_data buffer;
+ nt_runtime_data * prtdata;
+ ntapi_internals * __internals;
+
+ /* init */
+ __internals = __ntapi_internals();
+
+ /* once? */
+ if (__internals->rtdata) {
+ *rtdata = __internals->rtdata;
+ return NT_STATUS_SUCCESS;
+ }
+
+ if (!(argv = argv ? argv : __internals->ntapi_img_sec_bss->argv_envp_array))
+ return NT_STATUS_INVALID_PARAMETER_2;
+
+ /* integral process? */
+ if ((status = __ntapi->tt_get_short_option_meta_utf16(
+ __ntapi->tt_crc32_table(),
+ 'r',
+ argv,
+ &cmd_opt_meta)))
+ return status;
+
+ else if (argv[3])
+ status = NT_STATUS_INVALID_PARAMETER_MIX;
+
+ if ((status = __ntapi->tt_hex_utf16_to_uintptr(
+ cmd_opt_meta.value,
+ (uintptr_t *)&prtdata)))
+ return status;
+
+ if ((status = __ntapi->zw_read_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ prtdata,
+ (char *)&buffer,
+ sizeof(buffer),0)))
+ return status;
+
+ /* avoid confusion :-) */
+ process_params = ((nt_peb *)pe_get_peb_address())->process_params;
+
+ __ntapi->tt_memcpy_utf16(
+ (wchar16_t *)pe_va_from_rva(
+ process_params->command_line.buffer,
+ process_params->command_line.strlen - sizeof(runtime_arg)),
+ runtime_arg,
+ sizeof(runtime_arg));
+
+ *rtdata = prtdata;
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/process/ntapi_tt_init_runtime_data.c b/src/process/ntapi_tt_init_runtime_data.c
new file mode 100644
index 0000000..c7c2603
--- /dev/null
+++ b/src/process/ntapi_tt_init_runtime_data.c
@@ -0,0 +1,82 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_memory.h>
+#include <ntapi/nt_process.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tt_update_runtime_data(nt_runtime_data * rtdata)
+{
+ int32_t status;
+ nt_process_basic_information pbi;
+ uint32_t ret;
+ nt_oa oa = {sizeof(oa)};
+
+ /* process (self) */
+ rtdata->cid_self.process_id = pe_get_current_process_id();
+ rtdata->cid_self.thread_id = 0;
+
+ if ((status = __ntapi->zw_open_process(
+ &rtdata->hprocess_self,
+ NT_PROCESS_ALL_ACCESS,
+ &oa,&rtdata->cid_self)))
+ return status;
+
+ if (rtdata->cid_parent.process_id)
+ return NT_STATUS_SUCCESS;
+
+ /* process (parent) */
+ if ((status = __ntapi->zw_query_information_process(
+ rtdata->hprocess_self,
+ NT_PROCESS_BASIC_INFORMATION,
+ &pbi,sizeof(pbi),&ret)))
+ return status;
+
+ rtdata->cid_parent.process_id = pbi.inherited_from_unique_process_id;
+ rtdata->cid_parent.thread_id = 0;
+ rtdata->hprocess_parent = 0;
+
+ return NT_STATUS_SUCCESS;
+}
+
+int32_t __stdcall __ntapi_tt_init_runtime_data(nt_runtime_data * rtdata)
+{
+ int32_t status;
+ nt_peb * peb;
+ nt_oa oa = {sizeof(oa)};
+
+ /* init */
+ __ntapi->tt_aligned_block_memset(rtdata,0,sizeof(*rtdata));
+ peb = (nt_peb *)(pe_get_peb_address());
+
+ /* pid (self,parent) */
+ if ((status = __ntapi_tt_update_runtime_data(rtdata)))
+ return status;
+
+ /* std handles */
+ rtdata->hstdin = peb->process_params->hstdin;
+ rtdata->hstdout = peb->process_params->hstdout;
+ rtdata->hstderr = peb->process_params->hstderr;
+
+ if (__ntapi->tt_get_file_handle_type(rtdata->hstdin,&rtdata->stdin_type)) {
+ rtdata->hstdin = NT_INVALID_HANDLE_VALUE;
+ rtdata->stdin_type = 0;
+ }
+
+ if (__ntapi->tt_get_file_handle_type(rtdata->hstdout,&rtdata->stdout_type)) {
+ rtdata->hstdout = NT_INVALID_HANDLE_VALUE;
+ rtdata->stdout_type = 0;
+ }
+
+ if (__ntapi->tt_get_file_handle_type(rtdata->hstderr,&rtdata->stderr_type)) {
+ rtdata->hstderr = NT_INVALID_HANDLE_VALUE;
+ rtdata->stderr_type = 0;
+ }
+
+ return 0;
+}
diff --git a/src/process/ntapi_tt_map_image_as_data.c b/src/process/ntapi_tt_map_image_as_data.c
new file mode 100644
index 0000000..864f9cc
--- /dev/null
+++ b/src/process/ntapi_tt_map_image_as_data.c
@@ -0,0 +1,120 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <pemagine/pemagine.h>
+#include <ntapi/nt_section.h>
+#include <ntapi/nt_process.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+static nt_sqos const sqos = {
+ sizeof(sqos),
+ NT_SECURITY_IMPERSONATION,
+ NT_SECURITY_TRACKING_DYNAMIC,
+ 1};
+
+static int32_t __tt_exec_unmap_image(nt_executable_image * image, void * base, int32_t status)
+{
+ int32_t ret;
+
+ if (base)
+ if ((ret = __ntapi->zw_unmap_view_of_section(
+ NT_CURRENT_PROCESS_HANDLE,
+ base)))
+ return ret;
+
+ if (image->hsection)
+ if ((ret = __ntapi->zw_close(image->hsection)))
+ return ret;
+
+ return status;
+}
+
+int32_t __stdcall __ntapi_tt_exec_unmap_image(nt_executable_image * image)
+{
+ return __tt_exec_unmap_image(image,image->addr,0);
+}
+
+
+int32_t __stdcall __ntapi_tt_exec_map_image_as_data(nt_executable_image * image)
+{
+ int32_t status;
+ uint16_t * pi16;
+ uint32_t * pi32;
+ nt_sec_size sec_size;
+ size_t view_size;
+ void * base;
+ void * hsection;
+
+ struct pe_image_dos_hdr * dos;
+ struct pe_coff_file_hdr * coff;
+ union pe_opt_hdr * opt;
+ struct pe_sec_hdr * sec;
+
+ nt_oa oa = {sizeof(oa),
+ 0,0,0,0,(nt_sqos *)&sqos};
+
+ base = 0;
+ sec_size.quad = 0;
+ view_size = image->size;
+
+ if ((status = __ntapi->zw_create_section(
+ &hsection,
+ NT_SECTION_MAP_READ,
+ &oa,
+ &sec_size,
+ NT_PAGE_READONLY,
+ NT_SEC_RESERVE,image->hfile)))
+ return status;
+
+ if ((status = __ntapi->zw_map_view_of_section(
+ hsection,
+ NT_CURRENT_PROCESS_HANDLE,
+ &base,
+ 0,0,0,
+ &view_size,
+ NT_VIEW_UNMAP,0,
+ NT_PAGE_READONLY)))
+ return __tt_exec_unmap_image(
+ image,base,status);
+
+ if (!(dos = pe_get_image_dos_hdr_addr(base)))
+ return 0;
+
+ pi32 = (uint32_t *)dos->dos_lfanew;
+ if ((*pi32 + sizeof(*coff)) > view_size)
+ return __tt_exec_unmap_image(
+ image,base,NT_STATUS_INVALID_IMAGE_FORMAT);
+
+ if (!(coff = pe_get_image_coff_hdr_addr(base)))
+ return 0;
+
+ if (!(opt = pe_get_image_opt_hdr_addr(base)))
+ return 0;
+
+ sec = pe_get_image_section_tbl_addr(base);
+ pi16 = (uint16_t *)coff->num_of_sections;
+ if (((size_t)sec-(size_t)base + *pi16 * sizeof(*sec)) > view_size)
+ return __tt_exec_unmap_image(
+ image,base,NT_STATUS_INVALID_IMAGE_FORMAT);
+
+ /* subsystem: same offset (pe32, pe32+) */
+ pi16 = (uint16_t *)opt;
+ image->magic = *pi16;
+
+ pi16 = (uint16_t *)opt->opt_hdr_32.subsystem;
+ image->subsystem = *pi16;
+
+ pi16 = (uint16_t *)coff->characteristics;
+ image->characteristics = *pi16;
+
+ image->hsection = hsection;
+ image->addr = base;
+ image->size = view_size;
+
+ return status;
+}
diff --git a/src/process/tt_fork_v1.c b/src/process/tt_fork_v1.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/process/tt_fork_v1.c
diff --git a/src/pty/ntapi_pty_cancel.c b/src/pty/ntapi_pty_cancel.c
new file mode 100644
index 0000000..4bfbb79
--- /dev/null
+++ b/src/pty/ntapi_pty_cancel.c
@@ -0,0 +1,46 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_tty.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+#include "ntapi_pty.h"
+
+int32_t __stdcall __ntapi_pty_cancel(
+ nt_pty * pty,
+ nt_iosb * iosb)
+{
+ int32_t status;
+ nt_pty_io_msg msg;
+
+ __ntapi->tt_aligned_block_memset(
+ &msg,0,sizeof(msg));
+
+ msg.header.msg_type = NT_LPC_NEW_MESSAGE;
+ msg.header.data_size = sizeof(msg.data);
+ msg.header.msg_size = sizeof(msg);
+ msg.data.ttyinfo.opcode = NT_TTY_PTY_CANCEL;
+
+ msg.data.ioinfo.hpty = pty->hpty;
+ msg.data.ioinfo.luid.high = pty->luid.high;
+ msg.data.ioinfo.luid.low = pty->luid.low;
+
+ __ntapi->tt_guid_copy(
+ &msg.data.ioinfo.guid,
+ &pty->guid);
+
+ if ((status = __ntapi->zw_request_wait_reply_port(pty->hport,&msg,&msg)))
+ return status;
+ else if (msg.data.ttyinfo.status)
+ return msg.data.ttyinfo.status;
+
+ iosb->info = msg.data.ioinfo.iosb.info;
+ iosb->status = msg.data.ioinfo.iosb.status;
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/pty/ntapi_pty_fd.c b/src/pty/ntapi_pty_fd.c
new file mode 100644
index 0000000..ee0b426
--- /dev/null
+++ b/src/pty/ntapi_pty_fd.c
@@ -0,0 +1,232 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_tty.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+#include "ntapi_pty.h"
+
+static int32_t __stdcall __ntapi_pty_open_close(
+ nt_pty * pty,
+ nt_iosb * iosb,
+ int32_t opcode)
+{
+ int32_t status;
+ nt_pty_fd_msg msg;
+
+ __ntapi->tt_aligned_block_memset(&msg,0,sizeof(msg));
+
+ msg.header.msg_type = NT_LPC_NEW_MESSAGE;
+ msg.header.data_size = sizeof(msg.data);
+ msg.header.msg_size = sizeof(msg);
+ msg.data.ttyinfo.opcode = opcode;
+
+ msg.data.fdinfo.hpty = pty->hpty;
+ msg.data.fdinfo.access = pty->access;
+ msg.data.fdinfo.flags = pty->flags;
+ msg.data.fdinfo.share = pty->share;
+ msg.data.fdinfo.options = pty->options;
+
+ msg.data.fdinfo.luid.high = pty->luid.high;
+ msg.data.fdinfo.luid.low = pty->luid.low;
+
+ __ntapi_tt_guid_copy(
+ &msg.data.fdinfo.guid,
+ &pty->guid);
+
+ if ((status = __ntapi->zw_request_wait_reply_port(pty->hport,&msg,&msg)))
+ return status;
+ else if (msg.data.ttyinfo.status)
+ return msg.data.ttyinfo.status;
+
+ pty->hpty = msg.data.fdinfo.hpty;
+ pty->section = msg.data.fdinfo.section;
+ pty->section_size = msg.data.fdinfo.section_size;
+ pty->luid.high = msg.data.fdinfo.luid.high;
+ pty->luid.low = msg.data.fdinfo.luid.low;
+ iosb->status = msg.data.ttyinfo.status;
+ iosb->info = 0;
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+static int32_t __fastcall __ntapi_pty_free(nt_pty * pty)
+{
+ void * addr;
+ size_t size;
+
+ /* unmap section */
+ if (pty->section_addr)
+ __ntapi->zw_unmap_view_of_section(
+ NT_CURRENT_PROCESS_HANDLE,
+ pty->section_addr);
+
+ /* free control block */
+ addr = pty->addr;
+ size = pty->size;
+
+ return __ntapi->zw_free_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ &addr,
+ &size,
+ NT_MEM_RELEASE);
+}
+
+
+static int32_t __fastcall __ntapi_pty_fail(nt_pty * pty,int32_t status)
+{
+ __ntapi_pty_free(pty);
+ return status;
+}
+
+
+static int32_t __fastcall __ntapi_pty_alloc(nt_pty ** pty)
+{
+ int32_t status;
+ nt_pty * ctx;
+ size_t ctx_size;
+
+ /* allocate control block */
+ ctx = 0;
+ ctx_size = sizeof(nt_pty);
+
+ if ((status = __ntapi->zw_allocate_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ (void **)&ctx,
+ 0,&ctx_size,
+ NT_MEM_COMMIT,
+ NT_PAGE_READWRITE)))
+ return status;
+
+ /* init control block */
+ __ntapi->tt_aligned_block_memset(
+ ctx,0,ctx_size);
+
+ ctx->addr = ctx;
+ ctx->size = ctx_size;
+
+ *pty = ctx;
+ return NT_STATUS_SUCCESS;
+}
+
+static int32_t __ntapi_pty_connect(
+ void * hport,
+ nt_pty * ctx,
+ nt_iosb * iosb)
+{
+ int32_t status;
+
+ ctx->hport = hport
+ ? hport
+ : __ntapi_internals()->hport_tty_session;
+
+ /* request */
+ iosb = iosb ? iosb : &ctx->iosb;
+
+ if ((status = __ntapi_pty_open_close(ctx,iosb,NT_TTY_PTY_OPEN)))
+ return __ntapi_pty_fail(ctx,status);
+
+ /* map section */
+ if ((status = __ntapi->zw_map_view_of_section(
+ ctx->section,
+ NT_CURRENT_PROCESS_HANDLE,
+ &ctx->section_addr,
+ 0,ctx->section_size,
+ 0,&ctx->section_size,
+ NT_VIEW_UNMAP,0,
+ NT_PAGE_READWRITE)))
+ return __ntapi_pty_fail(ctx,status);
+
+ /* assume conforming clients, config for single lock try */
+ __ntapi->tt_sync_block_init(&ctx->sync[__PTY_READ],0,0,1,0,0);
+ __ntapi->tt_sync_block_init(&ctx->sync[__PTY_WRITE],0,0,1,0,0);
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+int32_t __stdcall __ntapi_pty_open(
+ void * hport,
+ nt_pty ** pty,
+ uint32_t desired_access,
+ nt_object_attributes* obj_attr,
+ nt_iosb * iosb,
+ uint32_t share_access,
+ uint32_t open_options)
+{
+ int32_t status;
+ uint32_t hash;
+ nt_guid guid;
+ nt_uuid_str_utf16 * guid_str;
+ nt_pty * ctx;
+
+ if (!obj_attr || !obj_attr->obj_name || !obj_attr->obj_name->buffer)
+ return NT_STATUS_INVALID_PARAMETER;
+
+ if (obj_attr->obj_name->strlen != __DEVICE_PATH_PREFIX_LEN + sizeof(nt_guid_str_utf16))
+ return NT_STATUS_OBJECT_PATH_INVALID;
+
+ hash = __ntapi->tt_buffer_crc32(
+ 0,
+ obj_attr->obj_name->buffer,
+ __DEVICE_PATH_PREFIX_LEN);
+
+ if (hash != __DEVICE_PATH_PREFIX_HASH)
+ return NT_STATUS_OBJECT_PATH_INVALID;
+
+ guid_str = (nt_uuid_str_utf16 *)
+ ((uintptr_t)obj_attr->obj_name->buffer + __DEVICE_PATH_PREFIX_LEN);
+
+ if (__ntapi->tt_utf16_string_to_guid(guid_str,&guid))
+ return NT_STATUS_OBJECT_NAME_INVALID;
+
+ /* control block */
+ if ((status = __ntapi_pty_alloc(&ctx)))
+ return status;
+
+ __ntapi_tt_guid_copy(
+ &ctx->guid,
+ &guid);
+
+ ctx->access = desired_access;
+ ctx->flags = obj_attr->obj_attr;
+ ctx->share = share_access;
+ ctx->options = open_options;
+
+ /* pts */
+ if (obj_attr->root_dir) {
+ ctx->luid.high = ((nt_pty *)obj_attr->root_dir)->luid.high;
+ ctx->luid.low = ((nt_pty *)obj_attr->root_dir)->luid.low;
+ }
+
+ if ((status = __ntapi_pty_connect(hport,ctx,iosb)))
+ return status;
+
+ *pty = ctx;
+
+ return NT_STATUS_SUCCESS;
+}
+
+int32_t __stdcall __ntapi_pty_reopen(
+ __in void * hport,
+ __in nt_pty * pty)
+{
+ return __ntapi_pty_connect(hport,pty,0);
+}
+
+int32_t __stdcall __ntapi_pty_close(nt_pty * pty)
+{
+ if (!pty || (pty->addr != pty))
+ return NT_STATUS_INVALID_PARAMETER;
+
+ __ntapi_pty_open_close(
+ pty,&pty->iosb,NT_TTY_PTY_CLOSE);
+
+ return __ntapi_pty_free(pty);
+}
diff --git a/src/pty/ntapi_pty_io.c b/src/pty/ntapi_pty_io.c
new file mode 100644
index 0000000..f110371
--- /dev/null
+++ b/src/pty/ntapi_pty_io.c
@@ -0,0 +1,130 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_tty.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+#include "ntapi_pty.h"
+
+static int32_t __stdcall __ntapi_pty_read_write(
+ nt_pty * pty,
+ void * hevent,
+ nt_io_apc_routine * apc_routine,
+ void * apc_context,
+ nt_iosb * iosb,
+ void * buffer,
+ size_t nbytes,
+ nt_large_integer * offset,
+ uint32_t * key,
+ int32_t opcode)
+{
+ int32_t status;
+ nt_pty_io_msg msg;
+ off_t soffset;
+ int mode;
+
+ mode = opcode - NT_TTY_PTY_READ;
+ soffset = mode * pty->section_size / 2;
+
+ if (offset && offset->quad)
+ return NT_STATUS_INVALID_PARAMETER;
+
+ else if (__ntapi->tt_sync_block_lock(&pty->sync[mode],1,0,0))
+ return NT_STATUS_RESOURCE_NOT_OWNED;
+
+ nbytes = nbytes <= pty->section_size / 2
+ ? nbytes
+ : pty->section_size / 2;
+
+ __ntapi->tt_aligned_block_memset(
+ &msg,0,sizeof(msg));
+
+ msg.header.msg_type = NT_LPC_NEW_MESSAGE;
+ msg.header.data_size = sizeof(msg.data);
+ msg.header.msg_size = sizeof(msg);
+ msg.data.ttyinfo.opcode = opcode;
+
+ msg.data.ioinfo.hpty = pty->hpty;
+ msg.data.ioinfo.hevent = hevent;
+ msg.data.ioinfo.apc_routine = apc_routine;
+ msg.data.ioinfo.apc_context = apc_context;
+ msg.data.ioinfo.key = key ? *key : 0;
+
+ msg.data.ioinfo.luid.high = pty->luid.high;
+ msg.data.ioinfo.luid.low = pty->luid.low;
+
+ msg.data.ioinfo.riosb = iosb;
+ msg.data.ioinfo.raddr = buffer;
+
+ __ntapi->tt_guid_copy(
+ &msg.data.ioinfo.guid,
+ &pty->guid);
+
+ msg.data.ioinfo.nbytes = nbytes;
+ msg.data.ioinfo.offset = soffset;
+
+ if (mode == __PTY_WRITE)
+ __ntapi->tt_generic_memcpy(
+ (char *)pty->section_addr + soffset,
+ (char *)buffer,
+ nbytes);
+
+ if ((status = __ntapi->zw_request_wait_reply_port(pty->hport,&msg,&msg)))
+ return status;
+ else if (msg.data.ttyinfo.status)
+ return msg.data.ttyinfo.status;
+
+ if (mode == __PTY_READ)
+ __ntapi->tt_generic_memcpy(
+ (char *)buffer,
+ (char *)pty->section_addr + soffset,
+ msg.data.ioinfo.iosb.info);
+
+ iosb->info = msg.data.ioinfo.iosb.info;
+ iosb->status = msg.data.ioinfo.iosb.status;
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+int32_t __stdcall __ntapi_pty_read(
+ __in nt_pty * pty,
+ __in void * hevent __optional,
+ __in nt_io_apc_routine * apc_routine __optional,
+ __in void * apc_context __optional,
+ __out nt_iosb * iosb,
+ __out void * buffer,
+ __in uint32_t nbytes,
+ __in nt_large_integer * offset __optional,
+ __in uint32_t * key __optional)
+{
+ return __ntapi_pty_read_write(
+ pty,
+ hevent,apc_routine,apc_context,
+ iosb,buffer,nbytes,offset,key,
+ NT_TTY_PTY_READ);
+}
+
+
+int32_t __stdcall __ntapi_pty_write(
+ __in nt_pty * pty,
+ __in void * hevent __optional,
+ __in nt_io_apc_routine * apc_routine __optional,
+ __in void * apc_context __optional,
+ __out nt_iosb * iosb,
+ __in void * buffer,
+ __in uint32_t nbytes,
+ __in nt_large_integer * offset __optional,
+ __in uint32_t * key __optional)
+{
+ return __ntapi_pty_read_write(
+ pty,
+ hevent,apc_routine,apc_context,
+ iosb,buffer,nbytes,offset,key,
+ NT_TTY_PTY_WRITE);
+}
diff --git a/src/pty/ntapi_pty_ioctl.c b/src/pty/ntapi_pty_ioctl.c
new file mode 100644
index 0000000..f828753
--- /dev/null
+++ b/src/pty/ntapi_pty_ioctl.c
@@ -0,0 +1,92 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_tty.h>
+#include <ntapi/nt_termios.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+#include "ntapi_pty.h"
+
+int32_t __stdcall __ntapi_pty_ioctl(
+ nt_pty * pty,
+ void * hevent __optional,
+ nt_io_apc_routine * apc_routine __optional,
+ void * apc_context __optional,
+ nt_iosb * iosb,
+ uint32_t ctlcode,
+ void * input_buffer __optional,
+ uint32_t input_buffer_length,
+ void * output_buffer __optional,
+ uint32_t output_buffer_length)
+{
+ int32_t status;
+ nt_pty_sigctl_msg msg;
+ nt_tty_sigctl_info * input;
+ nt_tty_sigctl_info * output;
+
+ if ((uintptr_t)input_buffer % sizeof(uintptr_t))
+ return NT_STATUS_DATATYPE_MISALIGNMENT_ERROR;
+ else if (input_buffer_length != sizeof(nt_tty_sigctl_info))
+ return NT_STATUS_INVALID_BUFFER_SIZE;
+ else if (!output_buffer)
+ return NT_STATUS_ACCESS_DENIED;
+ else if ((uintptr_t)output_buffer % sizeof(uintptr_t))
+ return NT_STATUS_DATATYPE_MISALIGNMENT_ERROR;
+ else if (output_buffer_length < sizeof(nt_tty_sigctl_info))
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ input = (nt_tty_sigctl_info *)input_buffer;
+ output = (nt_tty_sigctl_info *)output_buffer;
+
+ __ntapi->tt_aligned_block_memset(
+ &msg,0,sizeof(msg));
+
+ msg.header.msg_type = NT_LPC_NEW_MESSAGE;
+ msg.header.data_size = sizeof(msg.data);
+ msg.header.msg_size = sizeof(msg);
+ msg.data.ttyinfo.opcode = NT_TTY_PTY_IOCTL;
+
+ msg.data.ctlinfo.hpty = pty->hpty;
+ msg.data.ctlinfo.luid.high = pty->luid.high;
+ msg.data.ctlinfo.luid.low = pty->luid.low;
+ msg.data.ctlinfo.ctlcode = ctlcode;
+
+ __ntapi->tt_guid_copy(
+ &msg.data.ctlinfo.guid,
+ &pty->guid);
+
+ msg.data.ctlinfo.ctxarg[0] = input->ctxarg[0];
+ msg.data.ctlinfo.ctxarg[1] = input->ctxarg[1];
+ msg.data.ctlinfo.ctxarg[2] = input->ctxarg[2];
+ msg.data.ctlinfo.ctxarg[3] = input->ctxarg[3];
+
+ __ntapi->tt_generic_memcpy(
+ (char *)&input->terminfo,
+ (char *)&msg.data.ctlinfo.terminfo,
+ sizeof(input->terminfo));
+
+ __ntapi->tt_generic_memcpy(
+ (char *)&input->winsize,
+ (char *)&msg.data.ctlinfo.winsize,
+ sizeof(input->winsize));
+
+ if ((status = __ntapi->zw_request_wait_reply_port(pty->hport,&msg,&msg)))
+ return status;
+ else if (msg.data.ttyinfo.status)
+ return msg.data.ttyinfo.status;
+
+ __ntapi->tt_aligned_block_memcpy(
+ (uintptr_t *)output,
+ (uintptr_t *)&msg.data.ctlinfo,
+ sizeof(*output));
+
+ iosb->info = msg.data.ctlinfo.iosb.info;
+ iosb->status = msg.data.ctlinfo.iosb.status;
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/pty/ntapi_pty_query.c b/src/pty/ntapi_pty_query.c
new file mode 100644
index 0000000..57d31ee
--- /dev/null
+++ b/src/pty/ntapi_pty_query.c
@@ -0,0 +1,64 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_tty.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+#include "ntapi_pty.h"
+
+int32_t __stdcall __ntapi_pty_query(
+ nt_pty * pty,
+ nt_io_status_block * iosb,
+ void * pty_info,
+ uint32_t pty_info_length,
+ nt_pty_info_class pty_info_class)
+{
+ int32_t status;
+ nt_pty_sigctl_msg msg;
+ uintptr_t * info;
+
+ if ((pty_info_class<NT_PTY_BASIC_INFORMATION) || (pty_info_class>=NT_PTY_INFORMATION_CAP))
+ return NT_STATUS_INVALID_INFO_CLASS;
+ else if (pty_info_class == NT_PTY_BASIC_INFORMATION)
+ return NT_STATUS_NOT_IMPLEMENTED;
+ else if ((pty_info_class == NT_PTY_CLIENT_INFORMATION) && (pty_info_length != sizeof(nt_pty_client_info)))
+ return NT_STATUS_INVALID_PARAMETER;
+
+ __ntapi->tt_aligned_block_memset(
+ &msg,0,sizeof(msg));
+
+ msg.header.msg_type = NT_LPC_NEW_MESSAGE;
+ msg.header.data_size = sizeof(msg.data);
+ msg.header.msg_size = sizeof(msg);
+ msg.data.ttyinfo.opcode = NT_TTY_PTY_QUERY;
+
+ msg.data.ctlinfo.hpty = pty->hpty;
+ msg.data.ctlinfo.luid.high = pty->luid.high;
+ msg.data.ctlinfo.luid.low = pty->luid.low;
+ msg.data.ctlinfo.ctlcode = pty_info_class;
+
+ __ntapi->tt_guid_copy(
+ &msg.data.ctlinfo.guid,
+ &pty->guid);
+
+ if ((status = __ntapi->zw_request_wait_reply_port(pty->hport,&msg,&msg)))
+ return status;
+ else if (msg.data.ttyinfo.status)
+ return msg.data.ttyinfo.status;
+
+ iosb->info = msg.data.ctlinfo.iosb.info;
+ iosb->status = msg.data.ctlinfo.iosb.status;
+
+ info = (uintptr_t *)pty_info;
+ info[0] = msg.data.ctlinfo.ctxarg[0];
+ info[1] = msg.data.ctlinfo.ctxarg[1];
+ info[2] = msg.data.ctlinfo.ctxarg[2];
+ info[3] = msg.data.ctlinfo.ctxarg[3];
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/pty/ntapi_pty_set.c b/src/pty/ntapi_pty_set.c
new file mode 100644
index 0000000..1543e7c
--- /dev/null
+++ b/src/pty/ntapi_pty_set.c
@@ -0,0 +1,64 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_tty.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+#include "ntapi_pty.h"
+
+int32_t __stdcall __ntapi_pty_set(
+ nt_pty * pty,
+ nt_io_status_block * iosb,
+ void * pty_info,
+ uint32_t pty_info_length,
+ nt_pty_info_class pty_info_class)
+{
+ int32_t status;
+ nt_pty_sigctl_msg msg;
+ uintptr_t * info;
+
+ if ((pty_info_class<NT_PTY_BASIC_INFORMATION) || (pty_info_class>=NT_PTY_INFORMATION_CAP))
+ return NT_STATUS_INVALID_INFO_CLASS;
+ else if (pty_info_class == NT_PTY_BASIC_INFORMATION)
+ return NT_STATUS_NOT_IMPLEMENTED;
+ else if ((pty_info_class == NT_PTY_CLIENT_INFORMATION) && (pty_info_length != sizeof(nt_pty_client_info)))
+ return NT_STATUS_INVALID_PARAMETER;
+
+ __ntapi->tt_aligned_block_memset(
+ &msg,0,sizeof(msg));
+
+ msg.header.msg_type = NT_LPC_NEW_MESSAGE;
+ msg.header.data_size = sizeof(msg.data);
+ msg.header.msg_size = sizeof(msg);
+ msg.data.ttyinfo.opcode = NT_TTY_PTY_SET;
+
+ msg.data.ctlinfo.hpty = pty->hpty;
+ msg.data.ctlinfo.luid.high = pty->luid.high;
+ msg.data.ctlinfo.luid.low = pty->luid.low;
+ msg.data.ctlinfo.ctlcode = pty_info_class;
+
+ __ntapi->tt_guid_copy(
+ &msg.data.ctlinfo.guid,
+ &pty->guid);
+
+ info = (uintptr_t *)pty_info;
+ msg.data.ctlinfo.ctxarg[0] = info[0];
+ msg.data.ctlinfo.ctxarg[1] = info[1];
+ msg.data.ctlinfo.ctxarg[2] = info[2];
+ msg.data.ctlinfo.ctxarg[3] = info[3];
+
+ if ((status = __ntapi->zw_request_wait_reply_port(pty->hport,&msg,&msg)))
+ return status;
+ else if (msg.data.ttyinfo.status)
+ return msg.data.ttyinfo.status;
+
+ iosb->info = msg.data.ctlinfo.iosb.info;
+ iosb->status = msg.data.ctlinfo.iosb.status;
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/section/ntapi_tt_get_section_name.c b/src/section/ntapi_tt_get_section_name.c
new file mode 100644
index 0000000..744bfe7
--- /dev/null
+++ b/src/section/ntapi_tt_get_section_name.c
@@ -0,0 +1,32 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_memory.h>
+#include <ntapi/nt_section.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tt_get_section_name(
+ __in void * addr,
+ __out nt_mem_sec_name * buffer,
+ __in uint32_t buffer_size)
+{
+ size_t len;
+
+ /* init buffer */
+ buffer->section_name.strlen = 0;
+ buffer->section_name.maxlen = (uint16_t)(buffer_size - sizeof(nt_unicode_string));
+ buffer->section_name.buffer = buffer->section_name_buffer;
+
+ return __ntapi->zw_query_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ addr,
+ NT_MEMORY_SECTION_NAME,
+ buffer,
+ buffer_size,
+ &len);
+}
diff --git a/src/socket/ntapi_sc_accept.c b/src/socket/ntapi_sc_accept.c
new file mode 100644
index 0000000..a9f0a4e
--- /dev/null
+++ b/src/socket/ntapi_sc_accept.c
@@ -0,0 +1,79 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+typedef struct __addr_memcpy {
+ uint64_t d0;
+ uint64_t d1;
+} _addr_memcpy;
+
+
+int32_t __cdecl __ntapi_sc_accept(
+ __in nt_socket * hssock_listen,
+ __out nt_sockaddr * addr,
+ __out uint16_t * addrlen,
+ __out nt_socket * hssock_dedicated,
+ __in uintptr_t afdflags __optional,
+ __in uintptr_t tdiflags __optional,
+ __out nt_io_status_block * iosb __optional)
+{
+ int32_t status;
+
+ nt_afd_accept_info accept_info;
+ nt_io_status_block siosb;
+
+ _addr_memcpy * src;
+ _addr_memcpy * dst;
+
+ iosb = iosb ? iosb : &siosb;
+
+ /* establish kernel connection */
+ if ((status = __ntapi->sc_server_accept_connection(
+ hssock_listen,
+ &accept_info,
+ iosb)))
+ return status;
+
+ /* create connection-dedicated socket handle */
+ if ((status = __ntapi->sc_socket(
+ hssock_dedicated,
+ hssock_listen->domain,
+ hssock_listen->type,
+ hssock_listen->protocol,
+ 0,
+ 0,
+ 0)))
+ return status;
+
+ /* associate the dedicated handle with the connection */
+ if ((status = __ntapi->sc_server_duplicate_socket(
+ hssock_listen,
+ hssock_dedicated,
+ &accept_info,
+ 0)))
+ return status;
+
+ /* return address information */
+ if (addr) {
+ src = (_addr_memcpy *)&(accept_info.addr);
+ dst = (_addr_memcpy *)addr;
+
+ dst->d0 = src->d0;
+ dst->d1 = src->d1;
+ }
+
+ /* return address length information */
+ if (addrlen)
+ *addrlen = sizeof(nt_sockaddr);
+
+ return status;
+}
diff --git a/src/socket/ntapi_sc_bind_v1.c b/src/socket/ntapi_sc_bind_v1.c
new file mode 100644
index 0000000..df66656
--- /dev/null
+++ b/src/socket/ntapi_sc_bind_v1.c
@@ -0,0 +1,101 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+typedef struct _nt_afd_bind_msg {
+ uint32_t domain;
+ uint32_t type;
+ uint32_t service_flags;
+ char sa_data[14];
+} nt_afd_bind_msg;
+
+
+typedef struct __addr_memcpy {
+ uint16_t d0;
+ uint16_t d1;
+ uint16_t d2;
+ uint16_t d3;
+ uint16_t d4;
+ uint16_t d5;
+ uint16_t d6;
+ uint16_t d7;
+} _addr_memcpy;
+
+
+int32_t __cdecl __ntapi_sc_bind_v1(
+ __in nt_socket * hssocket,
+ __in const nt_sockaddr * addr,
+ __in uintptr_t addrlen,
+ __in uintptr_t service_flags __optional,
+ __out nt_sockaddr * sockaddr __optional,
+ __out nt_io_status_block * iosb __optional)
+{
+ nt_io_status_block siosb;
+ nt_afd_bind_msg afd_bind_req;
+ nt_afd_bind_msg afd_bind_rep;
+
+ _addr_memcpy * src;
+ _addr_memcpy * dst;
+
+ iosb = iosb ? iosb : &siosb;
+
+ /* service_flags */
+ if (!service_flags)
+ service_flags = 0x2000E;
+
+ /* afd_bind_req */
+ afd_bind_req.domain = hssocket->domain;
+ afd_bind_req.type = hssocket->type;
+ afd_bind_req.service_flags = (uint32_t)service_flags;
+
+ src = (_addr_memcpy *)addr;
+ dst = (_addr_memcpy *)&(afd_bind_req.sa_data);
+
+ dst->d0 = src->d1;
+ dst->d1 = src->d2;
+ dst->d2 = src->d3;
+ dst->d3 = src->d4;
+ dst->d4 = src->d5;
+ dst->d5 = src->d6;
+ dst->d6 = src->d7;
+
+ hssocket->iostatus = __ntapi->zw_device_io_control_file(
+ hssocket->hsocket,
+ hssocket->hevent,
+ 0,
+ 0,
+ iosb,
+ NT_AFD_IOCTL_BIND,
+ &afd_bind_req,
+ sizeof(afd_bind_req),
+ &afd_bind_rep,
+ sizeof(afd_bind_rep));
+
+ __ntapi->sc_wait(hssocket,iosb,0);
+
+ if (!hssocket->iostatus && sockaddr) {
+ src = (_addr_memcpy *)&(afd_bind_rep.sa_data);
+ dst = (_addr_memcpy *)sockaddr;
+
+ dst->d1 = src->d0;
+ dst->d2 = src->d1;
+ dst->d3 = src->d2;
+ dst->d4 = src->d3;
+ dst->d5 = src->d4;
+ dst->d6 = src->d5;
+ dst->d7 = src->d6;
+
+ sockaddr->sa_addr_in4.sa_family = hssocket->domain;
+ }
+
+ return hssocket->iostatus;
+}
diff --git a/src/socket/ntapi_sc_bind_v2.c b/src/socket/ntapi_sc_bind_v2.c
new file mode 100644
index 0000000..f9b503b
--- /dev/null
+++ b/src/socket/ntapi_sc_bind_v2.c
@@ -0,0 +1,85 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+typedef struct _nt_afd_bind_request {
+ uint32_t unknown;
+ nt_sockaddr addr;
+} nt_afd_bind_request;
+
+typedef struct _nt_afd_bind_reply {
+ nt_sockaddr addr;
+} nt_afd_bind_reply;
+
+typedef struct __addr_memcpy {
+ uint32_t d0;
+ uint32_t d1;
+ uint32_t d2;
+ uint32_t d3;
+} _addr_memcpy;
+
+
+int32_t __cdecl __ntapi_sc_bind_v2(
+ __in nt_socket * hssocket,
+ __in const nt_sockaddr * addr,
+ __in uintptr_t addrlen,
+ __in uintptr_t service_flags __optional,
+ __out nt_sockaddr * sockaddr __optional,
+ __out nt_io_status_block * iosb __optional)
+{
+ nt_io_status_block siosb;
+ nt_afd_bind_request afd_bind_req;
+ nt_afd_bind_reply afd_bind_rep;
+
+ _addr_memcpy * src;
+ _addr_memcpy * dst;
+
+ iosb = iosb ? iosb : &siosb;
+
+ /* request */
+ afd_bind_req.unknown = hssocket->domain;
+
+ src = (_addr_memcpy *)addr;
+ dst = (_addr_memcpy *)&(afd_bind_req.addr);
+
+ dst->d0 = src->d0;
+ dst->d1 = src->d1;
+ dst->d2 = src->d2;
+ dst->d3 = src->d3;
+
+ hssocket->iostatus = __ntapi->zw_device_io_control_file(
+ hssocket->hsocket,
+ hssocket->hevent,
+ 0,
+ 0,
+ iosb,
+ NT_AFD_IOCTL_BIND,
+ &afd_bind_req,
+ sizeof(afd_bind_req),
+ &afd_bind_rep,
+ sizeof(afd_bind_rep));
+
+ __ntapi->sc_wait(hssocket,iosb,0);
+
+ if (!hssocket->iostatus && sockaddr) {
+ /* return updated address information */
+ src = (_addr_memcpy *)&(afd_bind_rep);
+ dst = (_addr_memcpy *)sockaddr;
+
+ dst->d0 = src->d0;
+ dst->d1 = src->d1;
+ dst->d2 = src->d2;
+ dst->d3 = src->d3;
+ }
+
+ return hssocket->iostatus;
+}
diff --git a/src/socket/ntapi_sc_connect_v1.c b/src/socket/ntapi_sc_connect_v1.c
new file mode 100644
index 0000000..380dbc9
--- /dev/null
+++ b/src/socket/ntapi_sc_connect_v1.c
@@ -0,0 +1,93 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+/* weed in Redmond during the 1990's anyone? */
+typedef struct _nt_afd_connect_request {
+ uintptr_t unknown;
+ void * paddr;
+ void * hasync;
+ uint32_t type;
+ uint32_t service_flags;
+ char sa_data[14];
+ uint16_t hangover;
+ uint32_t unused;
+} nt_afd_connect_request;
+
+typedef struct __addr_memcpy {
+ uint16_t d0;
+ uint16_t d1;
+ uint16_t d2;
+ uint16_t d3;
+ uint16_t d4;
+ uint16_t d5;
+ uint16_t d6;
+ uint16_t d7;
+} _addr_memcpy;
+
+int32_t __cdecl __ntapi_sc_connect_v1(
+ __in nt_socket * hssocket,
+ __in nt_sockaddr * addr,
+ __in uintptr_t addrlen,
+ __in uintptr_t service_flags __optional,
+ __out nt_io_status_block * iosb __optional)
+{
+ nt_io_status_block siosb;
+ nt_afd_connect_request afd_connect_req;
+
+ _addr_memcpy * src;
+ _addr_memcpy * dst;
+
+ iosb = iosb ? iosb : &siosb;
+
+ /* service_flags */
+ if (!service_flags)
+ service_flags = 0x2000E;
+
+ /* afd_connect_req */
+ afd_connect_req.type = hssocket->type;
+ afd_connect_req.service_flags = (uint32_t)service_flags;
+
+ afd_connect_req.paddr = (void *)0;
+ afd_connect_req.hasync = (void *)0;
+
+ afd_connect_req.unknown = 0;
+ afd_connect_req.unused = 0;
+ afd_connect_req.hangover = 0;
+
+ src = (_addr_memcpy *)addr;
+ dst = (_addr_memcpy *)&(afd_connect_req.sa_data);
+
+ dst->d0 = src->d1;
+ dst->d1 = src->d2;
+ dst->d2 = src->d3;
+ dst->d3 = src->d4;
+ dst->d4 = src->d5;
+ dst->d5 = src->d6;
+ dst->d6 = src->d7;
+
+ hssocket->iostatus = __ntapi->zw_device_io_control_file(
+ hssocket->hsocket,
+ hssocket->hevent,
+ 0,
+ 0,
+ iosb,
+ NT_AFD_IOCTL_CONNECT,
+ &afd_connect_req,
+ sizeof(afd_connect_req),
+ (void *)0,
+ 0);
+
+ return hssocket->iostatus
+ ? __ntapi->sc_wait(hssocket,iosb,0)
+ : NT_STATUS_SUCCESS;
+}
diff --git a/src/socket/ntapi_sc_connect_v2.c b/src/socket/ntapi_sc_connect_v2.c
new file mode 100644
index 0000000..3857f6f
--- /dev/null
+++ b/src/socket/ntapi_sc_connect_v2.c
@@ -0,0 +1,69 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+typedef struct _nt_afd_connect_request {
+ uintptr_t unknown[2];
+ void * paddr;
+ nt_sockaddr addr;
+} nt_afd_connect_request;
+
+typedef struct __addr_memcpy {
+ uint64_t d0;
+ uint64_t d1;
+} _addr_memcpy;
+
+
+int32_t __cdecl __ntapi_sc_connect_v2(
+ __in nt_socket * hssocket,
+ __in nt_sockaddr * addr,
+ __in uintptr_t addrlen,
+ __in uintptr_t service_flags __optional,
+ __out nt_io_status_block * iosb __optional)
+{
+ nt_io_status_block siosb;
+ nt_afd_connect_request afd_connect_req;
+
+ _addr_memcpy * src;
+ _addr_memcpy * dst;
+
+ iosb = iosb ? iosb : &siosb;
+
+ /* afd_connect_req */
+ afd_connect_req.unknown[0] = 0;
+ afd_connect_req.unknown[1] = 0;
+
+ src = (_addr_memcpy *)addr;
+ dst = (_addr_memcpy *)&(afd_connect_req.addr);
+
+ dst->d0 = src->d0;
+ dst->d1 = src->d1;
+
+ afd_connect_req.paddr = &(afd_connect_req.addr);
+ afd_connect_req.addr.sa_addr_in4.sa_family = hssocket->domain;
+
+ hssocket->iostatus = __ntapi->zw_device_io_control_file(
+ hssocket->hsocket,
+ hssocket->hevent,
+ 0,
+ 0,
+ iosb,
+ NT_AFD_IOCTL_CONNECT,
+ &afd_connect_req,
+ sizeof(afd_connect_req),
+ (void *)0,
+ 0);
+
+ return hssocket->iostatus
+ ? __ntapi->sc_wait(hssocket,iosb,0)
+ : NT_STATUS_SUCCESS;
+}
diff --git a/src/socket/ntapi_sc_getsockname_v1.c b/src/socket/ntapi_sc_getsockname_v1.c
new file mode 100644
index 0000000..85a9357
--- /dev/null
+++ b/src/socket/ntapi_sc_getsockname_v1.c
@@ -0,0 +1,80 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+typedef struct _nt_afd_server_socket_name_info {
+ uint32_t unknown;
+ uint32_t type;
+ uint32_t service_flags;
+ char sa_data[14];
+} nt_afd_server_socket_name_info;
+
+
+struct __addr_memcpy {
+ uint16_t d0;
+ uint16_t d1;
+ uint16_t d2;
+ uint16_t d3;
+ uint16_t d4;
+ uint16_t d5;
+ uint16_t d6;
+ uint16_t d7;
+};
+
+
+int32_t __cdecl __ntapi_sc_getsockname_v1(
+ __in nt_socket * hssocket,
+ __in nt_sockaddr * addr,
+ __in uint16_t * addrlen,
+ __out nt_io_status_block * iosb __optional)
+{
+ nt_io_status_block siosb;
+ nt_afd_server_socket_name_info sock_name_info;
+
+ struct __addr_memcpy * asrc;
+ struct __addr_memcpy * adst;
+
+ iosb = iosb ? iosb : &siosb;
+
+ hssocket->iostatus = __ntapi->zw_device_io_control_file(
+ hssocket->hsocket,
+ hssocket->hevent,
+ 0,
+ 0,
+ iosb,
+ NT_AFD_IOCTL_GET_SOCK_NAME,
+ 0,
+ 0,
+ &sock_name_info,
+ sizeof(sock_name_info));
+
+ __ntapi->sc_wait(hssocket,iosb,0);
+
+ if (!hssocket->iostatus) {
+ addr->sa_addr_in4.sa_family = hssocket->domain;
+
+ asrc = (struct __addr_memcpy *)&(sock_name_info.sa_data);
+ adst = (struct __addr_memcpy *)addr;
+
+ adst->d1 = asrc->d0;
+ adst->d2 = asrc->d1;
+ adst->d3 = asrc->d2;
+ adst->d4 = asrc->d3;
+ adst->d5 = asrc->d4;
+ adst->d6 = asrc->d5;
+ adst->d7 = asrc->d6;
+
+ *addrlen = (uint16_t)iosb->info;
+ };
+
+ return hssocket->iostatus;
+}
diff --git a/src/socket/ntapi_sc_getsockname_v2.c b/src/socket/ntapi_sc_getsockname_v2.c
new file mode 100644
index 0000000..07313ac
--- /dev/null
+++ b/src/socket/ntapi_sc_getsockname_v2.c
@@ -0,0 +1,42 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __cdecl __ntapi_sc_getsockname_v2(
+ __in nt_socket * hssocket,
+ __in nt_sockaddr * addr,
+ __in uint16_t * addrlen,
+ __out nt_io_status_block * iosb __optional)
+{
+ nt_iosb siosb;
+
+ iosb = iosb ? iosb : &siosb;
+
+ hssocket->iostatus = __ntapi->zw_device_io_control_file(
+ hssocket->hsocket,
+ hssocket->hevent,
+ 0,
+ 0,
+ iosb,
+ NT_AFD_IOCTL_GET_SOCK_NAME,
+ 0,
+ 0,
+ addr,
+ sizeof(*addr));
+
+ __ntapi->sc_wait(hssocket,iosb,0);
+
+ if (!hssocket->iostatus)
+ *addrlen = (uint16_t)iosb->info;
+
+ return hssocket->iostatus;
+}
diff --git a/src/socket/ntapi_sc_listen.c b/src/socket/ntapi_sc_listen.c
new file mode 100644
index 0000000..cc3e66a
--- /dev/null
+++ b/src/socket/ntapi_sc_listen.c
@@ -0,0 +1,44 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __cdecl __ntapi_sc_listen(
+ __in nt_socket * hssocket,
+ __in uintptr_t backlog,
+ __out nt_io_status_block * iosb __optional)
+{
+ nt_afd_listen_info afd_listen;
+ nt_io_status_block siosb;
+
+ iosb = iosb ? iosb : &siosb;
+
+ /* afd_listen */
+ afd_listen.unknown_1st = 0;
+ afd_listen.unknown_2nd = 0;
+ afd_listen.backlog = (uint32_t)backlog;
+
+ hssocket->iostatus = __ntapi->zw_device_io_control_file(
+ hssocket->hsocket,
+ hssocket->hevent,
+ 0,
+ 0,
+ iosb,
+ NT_AFD_IOCTL_LISTEN,
+ &afd_listen,
+ sizeof(afd_listen),
+ 0,
+ 0);
+
+ return hssocket->iostatus
+ ? __ntapi->sc_wait(hssocket,iosb,0)
+ : NT_STATUS_SUCCESS;
+}
diff --git a/src/socket/ntapi_sc_recv.c b/src/socket/ntapi_sc_recv.c
new file mode 100644
index 0000000..8db3426
--- /dev/null
+++ b/src/socket/ntapi_sc_recv.c
@@ -0,0 +1,63 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __cdecl __ntapi_sc_recv(
+ __in nt_socket * hssocket,
+ __in const void * buffer,
+ __in size_t len,
+ __out ssize_t * bytes_received __optional,
+ __in uintptr_t afdflags __optional,
+ __in uintptr_t tdiflags __optional,
+ __out nt_io_status_block * iosb __optional)
+{
+ nt_afd_buffer afd_buffer;
+ nt_afd_recv_info afd_recv;
+ nt_io_status_block siosb;
+
+ iosb = iosb ? iosb : &siosb;
+
+ /* tdiflags */
+ if (tdiflags == 0)
+ tdiflags = NT_TDI_RECEIVE_NORMAL;
+
+ /* afd_buffer */
+ afd_buffer.length = len;
+ afd_buffer.buffer = (char *)buffer;
+
+ /* afd_recv */
+ afd_recv.afd_buffer_array = &afd_buffer;
+ afd_recv.buffer_count = 1;
+
+ afd_recv.afd_flags = (uint32_t)afdflags;
+ afd_recv.tdi_flags = (uint32_t)tdiflags;
+
+ hssocket->iostatus = __ntapi->zw_device_io_control_file(
+ hssocket->hsocket,
+ hssocket->hevent,
+ 0,
+ 0,
+ iosb,
+ NT_AFD_IOCTL_RECV,
+ &afd_recv,
+ sizeof(afd_recv),
+ 0,
+ 0);
+
+ if (hssocket->iostatus && (hssocket->ntflags & __NT_FILE_SYNC_IO))
+ __ntapi->sc_wait(hssocket,iosb,&hssocket->timeout);
+
+ if (!hssocket->iostatus && bytes_received)
+ *bytes_received = iosb->info;
+
+ return hssocket->iostatus;
+}
diff --git a/src/socket/ntapi_sc_send.c b/src/socket/ntapi_sc_send.c
new file mode 100644
index 0000000..2286d65
--- /dev/null
+++ b/src/socket/ntapi_sc_send.c
@@ -0,0 +1,59 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __cdecl __ntapi_sc_send(
+ __in nt_socket * hssocket,
+ __in const void * buffer,
+ __in size_t len,
+ __out ssize_t * bytes_sent __optional,
+ __in uintptr_t afdflags __optional,
+ __in uintptr_t tdiflags __optional,
+ __out nt_io_status_block * iosb __optional)
+{
+ nt_afd_buffer afd_buffer;
+ nt_afd_send_info afd_send;
+ nt_io_status_block siosb;
+
+ iosb = iosb ? iosb : &siosb;
+
+ /* afd_buffer */
+ afd_buffer.length = len;
+ afd_buffer.buffer = (char *)buffer;
+
+ /* afd_send */
+ afd_send.afd_buffer_array = &afd_buffer;
+ afd_send.buffer_count = 1;
+
+ afd_send.afd_flags = (uint32_t)afdflags;
+ afd_send.tdi_flags = (uint32_t)tdiflags;
+
+ hssocket->iostatus = __ntapi->zw_device_io_control_file(
+ hssocket->hsocket,
+ hssocket->hevent,
+ 0,
+ 0,
+ iosb,
+ NT_AFD_IOCTL_SEND,
+ &afd_send,
+ sizeof(afd_send),
+ 0,
+ 0);
+
+ if (hssocket->iostatus && (hssocket->ntflags & __NT_FILE_SYNC_IO))
+ __ntapi->sc_wait(hssocket,iosb,&hssocket->timeout);
+
+ if (!hssocket->iostatus && bytes_sent)
+ *bytes_sent = iosb->info;
+
+ return hssocket->iostatus;
+}
diff --git a/src/socket/ntapi_sc_server_accept_connection_v1.c b/src/socket/ntapi_sc_server_accept_connection_v1.c
new file mode 100644
index 0000000..0154ef7
--- /dev/null
+++ b/src/socket/ntapi_sc_server_accept_connection_v1.c
@@ -0,0 +1,78 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+typedef struct _nt_afd_server_accept_info {
+ uint32_t sequence;
+ uint32_t unknown;
+ uint32_t service_flags;
+ char sa_data[14];
+} nt_afd_server_accept_info;
+
+typedef struct __addr_memcpy {
+ uint16_t d0;
+ uint16_t d1;
+ uint16_t d2;
+ uint16_t d3;
+ uint16_t d4;
+ uint16_t d5;
+ uint16_t d6;
+ uint16_t d7;
+} _addr_memcpy;
+
+int32_t __cdecl __ntapi_sc_server_accept_connection_v1(
+ __in nt_socket * hssocket,
+ __out nt_afd_accept_info * accept_info,
+ __out nt_io_status_block * iosb __optional)
+{
+ nt_io_status_block siosb;
+ nt_afd_server_accept_info accept_info_buffer;
+
+ _addr_memcpy * asrc;
+ _addr_memcpy * adst;
+
+ iosb = iosb ? iosb : &siosb;
+
+ hssocket->iostatus = __ntapi->zw_device_io_control_file(
+ hssocket->hsocket,
+ hssocket->hevent,
+ 0,
+ 0,
+ iosb,
+ NT_AFD_IOCTL_ACCEPT,
+ 0,
+ 0,
+ &accept_info_buffer,
+ sizeof(accept_info_buffer));
+
+ if (hssocket->iostatus && (hssocket->ntflags & __NT_FILE_SYNC_IO))
+ __ntapi->sc_wait(hssocket,iosb,&hssocket->timeout);
+
+ if (hssocket->iostatus)
+ return hssocket->iostatus;
+
+ accept_info->sequence = accept_info_buffer.sequence;
+ accept_info->addr.sa_addr_in4.sa_family = hssocket->domain;
+
+ asrc = (_addr_memcpy *)&(accept_info_buffer.sa_data);
+ adst = (_addr_memcpy *)&(accept_info->addr);
+
+ adst->d1 = asrc->d0;
+ adst->d2 = asrc->d1;
+ adst->d3 = asrc->d2;
+ adst->d4 = asrc->d3;
+ adst->d5 = asrc->d4;
+ adst->d6 = asrc->d5;
+ adst->d7 = asrc->d6;
+
+ return hssocket->iostatus;
+}
diff --git a/src/socket/ntapi_sc_server_accept_connection_v2.c b/src/socket/ntapi_sc_server_accept_connection_v2.c
new file mode 100644
index 0000000..3520c75
--- /dev/null
+++ b/src/socket/ntapi_sc_server_accept_connection_v2.c
@@ -0,0 +1,44 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+typedef struct _nt_afd_server_accept_info {
+ uint32_t sequence;
+ nt_sockaddr addr;
+} nt_afd_server_accept_info;
+
+int32_t __cdecl __ntapi_sc_server_accept_connection_v2(
+ __in nt_socket * hssocket,
+ __out nt_afd_accept_info * accept_info,
+ __out nt_io_status_block * iosb __optional)
+{
+ nt_io_status_block siosb;
+
+ iosb = iosb ? iosb : &siosb;
+
+ hssocket->iostatus = __ntapi->zw_device_io_control_file(
+ hssocket->hsocket,
+ hssocket->hevent,
+ 0,
+ 0,
+ iosb,
+ NT_AFD_IOCTL_ACCEPT,
+ 0,
+ 0,
+ accept_info,
+ sizeof(nt_afd_server_accept_info));
+
+ if (hssocket->iostatus && (hssocket->ntflags & __NT_FILE_SYNC_IO))
+ __ntapi->sc_wait(hssocket,iosb,&hssocket->timeout);
+
+ return hssocket->iostatus;
+}
diff --git a/src/socket/ntapi_sc_server_duplicate_socket.c b/src/socket/ntapi_sc_server_duplicate_socket.c
new file mode 100644
index 0000000..4084593
--- /dev/null
+++ b/src/socket/ntapi_sc_server_duplicate_socket.c
@@ -0,0 +1,45 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __cdecl __ntapi_sc_server_duplicate_socket(
+ __in nt_socket * hssock_listen,
+ __in nt_socket * hssock_dedicated,
+ __in nt_afd_accept_info * accept_info,
+ __out nt_io_status_block * iosb __optional)
+{
+ nt_afd_duplicate_info duplicate_info;
+ nt_io_status_block siosb;
+
+ iosb = iosb ? iosb : &siosb;
+
+ /* duplicate_info */
+ duplicate_info.unknown = 0;
+ duplicate_info.sequence = accept_info->sequence;
+ duplicate_info.hsocket_dedicated = hssock_dedicated->hsocket;
+
+ hssock_dedicated->iostatus = __ntapi->zw_device_io_control_file(
+ hssock_listen->hsocket,
+ hssock_dedicated->hevent,
+ 0,
+ 0,
+ iosb,
+ NT_AFD_IOCTL_DUPLICATE,
+ &duplicate_info,
+ sizeof(duplicate_info),
+ 0,
+ 0);
+
+ return hssock_dedicated->iostatus
+ ? __ntapi->sc_wait(hssock_dedicated,iosb,0)
+ : NT_STATUS_SUCCESS;
+}
diff --git a/src/socket/ntapi_sc_shutdown.c b/src/socket/ntapi_sc_shutdown.c
new file mode 100644
index 0000000..115214c
--- /dev/null
+++ b/src/socket/ntapi_sc_shutdown.c
@@ -0,0 +1,65 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __cdecl __ntapi_sc_shutdown(
+ __in nt_socket * hssocket,
+ __in uintptr_t psxhow,
+ __in uintptr_t afdhow,
+ __out nt_io_status_block * iosb __optional)
+{
+ nt_afd_disconnect_info afd_disconnect;
+ nt_io_status_block siosb;
+
+ iosb = iosb ? iosb : &siosb;
+
+ if (afdhow == 0) {
+ switch (psxhow) {
+ case NT_SHUT_RD:
+ afdhow = NT_AFD_DISCONNECT_RD;
+ break;
+
+ case NT_SHUT_WR:
+ afdhow = NT_AFD_DISCONNECT_WR;
+ break;
+
+ case NT_SHUT_RDWR:
+ afdhow = NT_AFD_DISCONNECT_RD | NT_AFD_DISCONNECT_WR;
+ break;
+
+ default:
+ return NT_STATUS_INVALID_PARAMETER_2;
+ break;
+ }
+ }
+
+ afd_disconnect.shutdown_flags = (uint32_t)afdhow;
+ afd_disconnect.unknown[0] = 0xff;
+ afd_disconnect.unknown[1] = 0xff;
+ afd_disconnect.unknown[2] = 0xff;
+
+ hssocket->iostatus = __ntapi->zw_device_io_control_file(
+ hssocket->hsocket,
+ hssocket->hevent,
+ 0,
+ 0,
+ iosb,
+ NT_AFD_IOCTL_DISCONNECT,
+ &afd_disconnect,
+ sizeof(afd_disconnect),
+ 0,
+ 0);
+
+ return hssocket->iostatus
+ ? __ntapi->sc_wait(hssocket,iosb,0)
+ : NT_STATUS_SUCCESS;
+}
diff --git a/src/socket/ntapi_sc_socket_v1.c b/src/socket/ntapi_sc_socket_v1.c
new file mode 100644
index 0000000..d57f212
--- /dev/null
+++ b/src/socket/ntapi_sc_socket_v1.c
@@ -0,0 +1,118 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+typedef struct _nt_afd_socket_ea {
+ uint32_t next_entry_offset;
+ unsigned char ea_flags;
+ unsigned char ea_name_length;
+ uint16_t ea_value_length;
+ char afd_open_packet[0x10];
+ uint32_t value_1st;
+ uint32_t value_2nd;
+ uint32_t device_name_length;
+ wchar16_t device_name[0x0b];
+ uint32_t ea_ext[4];
+} nt_afd_socket_ea;
+
+int32_t __cdecl __ntapi_sc_socket_v1(
+ __out nt_socket * hssocket,
+ __in uint16_t domain,
+ __in uint16_t type,
+ __in uint32_t protocol,
+ __in uint32_t desired_access __optional,
+ __in nt_sqos * sqos __optional,
+ __out nt_io_status_block * iosb __optional)
+{
+ int32_t status;
+ nt_object_attributes oa;
+ nt_io_status_block siosb;
+ nt_sqos ssqos;
+ nt_unicode_string nt_afdep;
+ uint32_t ea_length;
+ void * _hsocket;
+
+ wchar16_t afd_end_point[] = {
+ '\\','D','e','v','i','c','e',
+ '\\','A','f','d',
+ '\\','E','n','d','P','o','i','n','t',
+ 0};
+
+ /* tcp as default extended attribute */
+ nt_afd_socket_ea afd_ea = {
+ 0,
+ 0,
+ 0x0f,
+ 0x28,
+ {'A','f','d','O','p','e','n','P','a','c','k','e','t','X','X',0},
+ 0,0,
+ 0x16,
+ {'\\','D','e','v','i','c','e','\\','T','c','p'},
+ {0}};
+
+ ea_length = 0x43;
+
+ __ntapi->rtl_init_unicode_string(&nt_afdep,afd_end_point);
+
+ if (!desired_access)
+ desired_access = NT_GENERIC_READ \
+ | NT_GENERIC_WRITE \
+ | NT_SEC_SYNCHRONIZE \
+ | NT_SEC_WRITE_DAC;
+
+ if (!sqos) {
+ ssqos.length = sizeof(ssqos);
+ ssqos.impersonation_level = NT_SECURITY_IMPERSONATION;
+ ssqos.context_tracking_mode = NT_SECURITY_TRACKING_DYNAMIC;
+ ssqos.effective_only = 1;
+ sqos = &ssqos;
+ }
+
+ oa.len = sizeof(oa);
+ oa.root_dir = (void *)0;
+ oa.obj_name = &nt_afdep;
+ oa.obj_attr = NT_OBJ_CASE_INSENSITIVE | NT_OBJ_INHERIT;
+ oa.sec_desc = (nt_security_descriptor *)0;
+ oa.sec_qos = sqos;
+
+ iosb = iosb ? iosb : &siosb;
+
+ if ((status = __ntapi->zw_create_file(
+ &_hsocket,
+ desired_access,
+ &oa,
+ iosb,
+ 0,
+ 0,
+ NT_FILE_SHARE_READ | NT_FILE_SHARE_WRITE,
+ NT_FILE_OPEN_IF,
+ 0,
+ &afd_ea,
+ ea_length)))
+ return status;
+
+ oa.obj_name = 0;
+ oa.obj_attr = 0;
+
+ if (status == NT_STATUS_SUCCESS) {
+ hssocket->hsocket = _hsocket;
+ hssocket->ntflags = 0;
+ hssocket->domain = domain;
+ hssocket->type = type;
+ hssocket->protocol = protocol;
+ hssocket->timeout.quad = 0;
+ hssocket->iostatus = NT_STATUS_SUCCESS;
+ hssocket->waitstatus = NT_STATUS_SUCCESS;
+ }
+
+ return status;
+}
diff --git a/src/socket/ntapi_sc_socket_v2.c b/src/socket/ntapi_sc_socket_v2.c
new file mode 100644
index 0000000..069c596
--- /dev/null
+++ b/src/socket/ntapi_sc_socket_v2.c
@@ -0,0 +1,124 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_file.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+typedef struct _nt_socket_attr {
+ uint32_t datagram;
+ uint32_t unknown;
+ uint32_t domain;
+ uint32_t type;
+ uint32_t protocol;
+} nt_socket_attr;
+
+typedef struct _nt_afd_socket_ea {
+ uint32_t next_entry_offset;
+ unsigned char ea_flags;
+ unsigned char ea_name_length;
+ uint16_t ea_value_length;
+ char afd_open_packet[16];
+ nt_socket_attr sattr;
+ uint32_t ea_ext[4];
+} nt_afd_socket_ea;
+
+int32_t __cdecl __ntapi_sc_socket_v2(
+ __out nt_socket * hssocket,
+ __in uint16_t domain,
+ __in uint16_t type,
+ __in uint32_t protocol,
+ __in uint32_t desired_access __optional,
+ __in nt_sqos * sqos __optional,
+ __out nt_io_status_block * iosb __optional)
+{
+ int32_t status;
+ nt_object_attributes oa;
+ nt_io_status_block siosb;
+ nt_sqos ssqos;
+ nt_unicode_string nt_afdep;
+ uint32_t ea_length;
+ void * _hsocket;
+
+ wchar16_t afd_end_point[] = {
+ '\\','D','e','v','i','c','e',
+ '\\','A','f','d',
+ '\\','E','n','d','P','o','i','n','t',
+ 0};
+
+ nt_afd_socket_ea afd_ea = {
+ 0,
+ 0,
+ 0x0f,
+ 0x20,
+ {'A','f','d','O','p','e','n','P','a','c','k','e','t','X','X',0},
+ {0},
+ {0}};
+
+ ea_length = sizeof(afd_ea);
+
+ afd_ea.sattr.domain = domain;
+ afd_ea.sattr.type = type;
+ afd_ea.sattr.protocol = protocol;
+
+ afd_ea.sattr.datagram = (type == NT_SOCK_DGRAM) ? protocol : 0;
+
+ __ntapi->rtl_init_unicode_string(&nt_afdep,afd_end_point);
+
+ if (!desired_access)
+ desired_access = NT_GENERIC_READ \
+ | NT_GENERIC_WRITE \
+ | NT_SEC_SYNCHRONIZE \
+ | NT_SEC_WRITE_DAC;
+
+ if (!sqos) {
+ ssqos.length = sizeof(ssqos);
+ ssqos.impersonation_level = NT_SECURITY_IMPERSONATION;
+ ssqos.context_tracking_mode = NT_SECURITY_TRACKING_DYNAMIC;
+ ssqos.effective_only = 1;
+ sqos = &ssqos;
+ }
+
+ oa.len = sizeof(oa);
+ oa.root_dir = (void *)0;
+ oa.obj_name = &nt_afdep;
+ oa.obj_attr = NT_OBJ_CASE_INSENSITIVE | NT_OBJ_INHERIT;
+ oa.sec_desc = (nt_security_descriptor *)0;
+ oa.sec_qos = sqos;
+
+ iosb = iosb ? iosb : &siosb;
+
+ if ((status = __ntapi->zw_create_file(
+ &_hsocket,
+ desired_access,
+ &oa,
+ iosb,
+ 0,
+ 0,
+ NT_FILE_SHARE_READ | NT_FILE_SHARE_WRITE,
+ NT_FILE_OPEN_IF,
+ 0,
+ &afd_ea,
+ ea_length)))
+ return status;
+
+ oa.obj_name = 0;
+ oa.obj_attr = 0;
+
+ hssocket->hsocket = _hsocket;
+ hssocket->ntflags = 0;
+ hssocket->domain = domain;
+ hssocket->type = type;
+ hssocket->protocol = protocol;
+ hssocket->timeout.quad = 0;
+ hssocket->iostatus = NT_STATUS_SUCCESS;
+ hssocket->waitstatus = NT_STATUS_SUCCESS;
+
+ return status;
+}
diff --git a/src/socket/ntapi_sc_wait.c b/src/socket/ntapi_sc_wait.c
new file mode 100644
index 0000000..3bfad28
--- /dev/null
+++ b/src/socket/ntapi_sc_wait.c
@@ -0,0 +1,42 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_sync.h>
+#include <ntapi/nt_socket.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __cdecl __ntapi_sc_wait(nt_socket * hssocket, nt_iosb * iosb, nt_timeout * timeout)
+{
+ nt_iosb cancel;
+
+ timeout = (timeout && timeout->quad)
+ ? timeout
+ : 0;
+
+ if (hssocket->hevent && (hssocket->iostatus == NT_STATUS_PENDING)) {
+ hssocket->waitstatus = __ntapi->zw_wait_for_single_object(
+ hssocket->hevent,
+ !!(hssocket->ntflags & NT_FILE_SYNCHRONOUS_IO_ALERT),
+ timeout);
+
+ switch (hssocket->waitstatus) {
+ case NT_STATUS_SUCCESS:
+ hssocket->iostatus = NT_STATUS_SUCCESS;
+ break;
+
+ case NT_STATUS_ALERTED:
+ hssocket->iostatus = NT_STATUS_ALERTED;
+ __ntapi->zw_cancel_io_file(
+ hssocket->hsocket,
+ &cancel);
+ break;
+ }
+ }
+
+ return hssocket->iostatus;
+}
diff --git a/src/string/ntapi_tt_aligned_block_memcpy.c b/src/string/ntapi_tt_aligned_block_memcpy.c
new file mode 100644
index 0000000..43e1a49
--- /dev/null
+++ b/src/string/ntapi_tt_aligned_block_memcpy.c
@@ -0,0 +1,50 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_string.h>
+
+uintptr_t * __cdecl __ntapi_tt_aligned_block_memcpy(
+ __in uintptr_t * dst,
+ __in uintptr_t * src,
+ __in size_t bytes)
+{
+ uintptr_t * ptr = (uintptr_t *)dst;
+
+ for (bytes/=sizeof(uintptr_t); bytes; bytes--)
+ *dst++ = *src++;
+
+ return ptr;
+}
+
+
+void * __cdecl __ntapi_tt_generic_memcpy(
+ __in void * dst,
+ __in const void * src,
+ __in size_t bytes)
+{
+ char * ch_dst;
+ const char * ch_src;
+
+ if (!bytes)
+ return dst;
+
+ else if (!(bytes % sizeof(size_t))
+ && (!(uintptr_t)dst % sizeof(size_t))
+ && (!(uintptr_t)src % sizeof(size_t)))
+ return __ntapi_tt_aligned_block_memcpy(
+ (uintptr_t *)dst,
+ (uintptr_t *)src,
+ bytes);
+
+ ch_dst = (char *)dst;
+ ch_src = (const char *)src;
+
+ for (; bytes; bytes--)
+ *ch_dst++ = *ch_src++;
+
+ return dst;
+}
diff --git a/src/string/ntapi_tt_aligned_block_memset.c b/src/string/ntapi_tt_aligned_block_memset.c
new file mode 100644
index 0000000..8e64360
--- /dev/null
+++ b/src/string/ntapi_tt_aligned_block_memset.c
@@ -0,0 +1,57 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+
+void * __cdecl __ntapi_tt_aligned_block_memset(
+ __in void * block,
+ __in uintptr_t val,
+ __in size_t bytes)
+{
+ uintptr_t * ptr = (uintptr_t *)block;
+
+ for (bytes/=sizeof(uintptr_t); bytes; bytes--)
+ *ptr++=val;
+
+ return block;
+}
+
+void * __cdecl __ntapi_tt_generic_memset(
+ __in void * dst,
+ __in uintptr_t val,
+ __in size_t bytes)
+{
+ char c;
+ char * ch;
+ int i;
+ size_t abytes;
+
+ if (!bytes)
+ return dst;
+
+ else if (!(bytes % sizeof(size_t))
+ && (!(uintptr_t)dst % sizeof(size_t)))
+ return __ntapi_tt_aligned_block_memset(
+ dst,val,bytes);
+
+ c = (char)val;
+ for (i=0; i<sizeof(size_t); i++, val <<= 8)
+ val += c;
+
+ for (ch=(char *)dst; (size_t)ch % sizeof(size_t); ch++, bytes--)
+ *ch = c;
+
+ abytes = bytes / sizeof(size_t) * sizeof(size_t);
+ __ntapi_tt_aligned_block_memset(ch,val,abytes);
+
+ bytes -= abytes;
+ ch += abytes;
+
+ for (; bytes; ch++, bytes--)
+ *ch = c;
+
+ return dst;
+}
diff --git a/src/string/ntapi_tt_aligned_memcpy_utf16.c b/src/string/ntapi_tt_aligned_memcpy_utf16.c
new file mode 100644
index 0000000..2035814
--- /dev/null
+++ b/src/string/ntapi_tt_aligned_memcpy_utf16.c
@@ -0,0 +1,70 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+
+wchar16_t * __cdecl __ntapi_tt_aligned_memcpy_utf16(
+ __in uintptr_t * dst,
+ __in uintptr_t * src,
+ __in size_t bytes)
+{
+ size_t aligned_block;
+ size_t copied;
+
+ wchar16_t * wch_src;
+ wchar16_t * wch_dst;
+
+ #if defined (__X86_64_MODEL)
+ uint32_t * uint32_src;
+ uint32_t * uint32_dst;
+ #endif
+
+ aligned_block = bytes;
+ aligned_block /= sizeof(uintptr_t);
+ aligned_block *= sizeof(uintptr_t);
+
+ copied = 0;
+
+ while (copied < aligned_block) {
+ *dst = *src;
+ src++;
+ dst++;
+ copied += sizeof(uintptr_t);
+ }
+
+ #if defined (__X86_64_MODEL)
+ switch (bytes % sizeof(uintptr_t)) {
+ case 6:
+ uint32_src = (uint32_t *)src;
+ uint32_dst = (uint32_t *)dst;
+ *uint32_dst = *uint32_src;
+
+ uint32_src++;
+ uint32_dst++;
+
+ /* make the compiler happy */
+ wch_src = (wchar16_t *)uint32_src;
+ wch_dst = (wchar16_t *)uint32_dst;
+ *wch_dst = *wch_src;
+ break;
+
+ case 4:
+ uint32_src = (uint32_t *)src;
+ uint32_dst = (uint32_t *)dst;
+ *uint32_dst = *uint32_src;
+ break;
+ }
+ #endif
+
+ if (bytes % sizeof(uintptr_t)) {
+ /* the remainder must be 2 */
+ wch_src = (wchar16_t *)src;
+ wch_dst = (wchar16_t *)dst;
+ *wch_dst = *wch_src;
+ }
+
+ return (wchar16_t *)dst;
+}
diff --git a/src/string/ntapi_tt_hex_utf16_to_uintptr.c b/src/string/ntapi_tt_hex_utf16_to_uintptr.c
new file mode 100644
index 0000000..3b1f354
--- /dev/null
+++ b/src/string/ntapi_tt_hex_utf16_to_uintptr.c
@@ -0,0 +1,124 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_status.h>
+
+int32_t __fastcall __ntapi_tt_hex_utf16_to_uint32(
+ __in wchar16_t hex_key_utf16[8],
+ __out uint32_t * key)
+{
+ int i;
+ unsigned char uch[8];
+ unsigned char ubytes[4];
+ uint32_t * key_ret;
+
+ /* input validation */
+ i = 0;
+ do {
+ if (/* [a-f],[[A-F],[0-9] */
+ ((hex_key_utf16[i] >= 'a') && (hex_key_utf16[i] <= 'f'))
+ || ((hex_key_utf16[i] >= 'A') && (hex_key_utf16[i] <= 'F'))
+ || ((hex_key_utf16[i] >= '0') && (hex_key_utf16[i] <= '9')))
+ /* valid hex character */
+ i++;
+ else
+ return NT_STATUS_ILLEGAL_CHARACTER;
+ } while (i < 8);
+
+ /* intermediate step: little endian byte order */
+ uch[0] = (unsigned char)hex_key_utf16[6];
+ uch[1] = (unsigned char)hex_key_utf16[7];
+ uch[2] = (unsigned char)hex_key_utf16[4];
+ uch[3] = (unsigned char)hex_key_utf16[5];
+ uch[4] = (unsigned char)hex_key_utf16[2];
+ uch[5] = (unsigned char)hex_key_utf16[3];
+ uch[6] = (unsigned char)hex_key_utf16[0];
+ uch[7] = (unsigned char)hex_key_utf16[1];
+
+ for (i=0; i<8; i++) {
+ /* 'a' > 'A' > '0' */
+ if (uch[i] >= 'a')
+ uch[i] -= ('a' - 0x0a);
+ else if (uch[i] >= 'A')
+ uch[i] -= ('A' - 0x0a);
+ else
+ uch[i] -= '0';
+ }
+
+ ubytes[0] = uch[0] * 0x10 + uch[1];
+ ubytes[1] = uch[2] * 0x10 + uch[3];
+ ubytes[2] = uch[4] * 0x10 + uch[5];
+ ubytes[3] = uch[6] * 0x10 + uch[7];
+
+ key_ret = (uint32_t *)ubytes;
+ *key = *key_ret;
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+int32_t __fastcall __ntapi_tt_hex_utf16_to_uint64(
+ __in wchar16_t hex_key_utf16[16],
+ __out uint64_t * key)
+{
+ int32_t status;
+ uint32_t x64_key[2];
+ uint64_t * key_ret;
+
+ status = __ntapi_tt_hex_utf16_to_uint32(
+ &hex_key_utf16[0],
+ &x64_key[1]);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ status = __ntapi_tt_hex_utf16_to_uint32(
+ &hex_key_utf16[8],
+ &x64_key[0]);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ key_ret = (uint64_t *)x64_key;
+ *key = *key_ret;
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+int32_t __fastcall __ntapi_tt_hex_utf16_to_uintptr(
+ __in wchar16_t hex_key_utf16[],
+ __out uintptr_t * key)
+{
+ #if defined (__NT32)
+ return __ntapi_tt_hex_utf16_to_uint32(hex_key_utf16,key);
+ #elif defined (__NT64)
+ return __ntapi_tt_hex_utf16_to_uint64(hex_key_utf16,key);
+ #endif
+}
+
+
+int32_t __fastcall __ntapi_tt_hex_utf16_to_uint16(
+ __in wchar16_t hex_key_utf16[4],
+ __out uint16_t * key)
+{
+ int32_t ret;
+ uint32_t dword_key;
+ wchar16_t hex_buf[8] = {'0','0','0','0'};
+
+ hex_buf[4] = hex_key_utf16[0];
+ hex_buf[5] = hex_key_utf16[1];
+ hex_buf[6] = hex_key_utf16[2];
+ hex_buf[7] = hex_key_utf16[3];
+
+ ret = __ntapi_tt_hex_utf16_to_uint32(hex_buf,&dword_key);
+
+ if (ret == NT_STATUS_SUCCESS)
+ *key = (uint16_t)dword_key;
+
+ return ret;
+}
diff --git a/src/string/ntapi_tt_init_unicode_string_from_utf16.c b/src/string/ntapi_tt_init_unicode_string_from_utf16.c
new file mode 100644
index 0000000..96673b4
--- /dev/null
+++ b/src/string/ntapi_tt_init_unicode_string_from_utf16.c
@@ -0,0 +1,26 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <pemagine/pemagine.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+void __ntapi_tt_init_unicode_string_from_utf16(
+ __out nt_unicode_string * str_dest,
+ __in wchar16_t * str_src)
+{
+ if ((intptr_t)str_src) {
+ str_dest->strlen = (uint16_t)__ntapi->tt_string_null_offset_short((const int16_t *)str_src);
+ str_dest->maxlen = str_dest->strlen + sizeof(uint16_t);
+ str_dest->buffer = (uint16_t *)str_src;
+ } else {
+ str_dest->strlen = 0;
+ str_dest->maxlen = 0;
+ str_dest->buffer = (uint16_t *)0;
+ }
+}
\ No newline at end of file
diff --git a/src/string/ntapi_tt_memcpy_utf16.c b/src/string/ntapi_tt_memcpy_utf16.c
new file mode 100644
index 0000000..0a2b7af
--- /dev/null
+++ b/src/string/ntapi_tt_memcpy_utf16.c
@@ -0,0 +1,28 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <pemagine/pemagine.h>
+
+wchar16_t * __cdecl __ntapi_tt_memcpy_utf16(
+ __in wchar16_t * dst,
+ __in wchar16_t * src,
+ __in size_t bytes)
+{
+ wchar16_t * wch_cap;
+ wchar16_t * wch_ret;
+
+ wch_cap = (wchar16_t *)((uintptr_t)src + bytes);
+ wch_ret = dst;
+
+ while (src < wch_cap) {
+ *dst = *src;
+ src++;
+ dst++;
+ }
+
+ return wch_ret;
+}
diff --git a/src/string/ntapi_tt_string_null_offset.c b/src/string/ntapi_tt_string_null_offset.c
new file mode 100644
index 0000000..3565acb
--- /dev/null
+++ b/src/string/ntapi_tt_string_null_offset.c
@@ -0,0 +1,93 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_string.h>
+#include "ntapi_impl.h"
+
+size_t __cdecl __ntapi_tt_string_null_offset_multibyte(
+ __in const char * str)
+{
+ const char * cap;
+ const uintptr_t * ptr;
+
+ #define HIGH_BIT_TEST (uintptr_t)0x0101010101010101
+ #define AND_BITS (uintptr_t)0x8080808080808080
+
+ cap = str;
+ while ((uintptr_t)cap % sizeof(uintptr_t)) {
+ if (!(*cap))
+ return cap - str;
+ cap++;
+ }
+
+ ptr = (uintptr_t *)cap;
+ while (!((*ptr - HIGH_BIT_TEST) & ~(*ptr) & AND_BITS))
+ ptr++;
+
+ cap = (const char *)ptr;
+ while (*cap)
+ cap++;
+
+ return cap - str;
+}
+
+
+size_t __cdecl __ntapi_tt_string_null_offset_short(
+ __in const int16_t * str)
+{
+ const int16_t * cap;
+
+ cap = str;
+ while (*cap)
+ cap++;
+
+ return (size_t)cap - (size_t)str;
+}
+
+
+size_t __cdecl __ntapi_tt_string_null_offset_dword(
+ __in const int32_t * str)
+{
+ const int32_t * cap;
+
+ cap = str;
+ while (*cap)
+ cap++;
+
+ return (size_t)cap - (size_t)str;
+}
+
+size_t __cdecl __ntapi_tt_string_null_offset_qword(
+ __in const int64_t * str)
+{
+ const int64_t * cap;
+
+ cap = str;
+ while (*cap)
+ cap++;
+
+ return (size_t)cap - (size_t)str;
+}
+
+size_t __cdecl __ntapi_tt_string_null_offset_ptrsize(
+ __in const intptr_t *str)
+{
+ const intptr_t * cap;
+
+ cap = str;
+ while (*cap)
+ cap++;
+
+ return (size_t)cap - (size_t)str;
+}
+
+size_t __cdecl __ntapi_wcslen(const wchar16_t * str)
+{
+ size_t len;
+ len = __ntapi_tt_string_null_offset_short((const int16_t *)str);
+ return len / 2;
+}
diff --git a/src/string/ntapi_tt_uintptr_to_hex_utf16.c b/src/string/ntapi_tt_uintptr_to_hex_utf16.c
new file mode 100644
index 0000000..59e063f
--- /dev/null
+++ b/src/string/ntapi_tt_uintptr_to_hex_utf16.c
@@ -0,0 +1,87 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+
+static void __fastcall __ntapi_tt_uint_to_hex_utf16(
+ __in uint64_t key,
+ __out wchar16_t * buffer,
+ __in unsigned bits)
+{
+ unsigned i;
+ uint32_t hex_buf[4];
+ unsigned char * hex_chars;
+ unsigned char * uch;
+ unsigned offset;
+ unsigned bytes;
+
+ hex_buf[0] = ('3' << 24) | ('2' << 16) | ('1' << 8) | '0';
+ hex_buf[1] = ('7' << 24) | ('6' << 16) | ('5' << 8) | '4';
+ hex_buf[2] = ('b' << 24) | ('a' << 16) | ('9' << 8) | '8';
+ hex_buf[3] = ('f' << 24) | ('e' << 16) | ('d' << 8) | 'c';
+
+ uch = (unsigned char *)&key;
+ hex_chars = (unsigned char *)&hex_buf;
+
+ bytes = bits / 8;
+ offset = bits / 4;
+
+ for (i = 0; i < bytes; i++) {
+ buffer[offset - 1 - (i*2)] = hex_chars[uch[i] % 16];
+ buffer[offset - 2 - (i*2)] = hex_chars[uch[i] / 16];
+ }
+}
+
+
+void __fastcall __ntapi_tt_uint16_to_hex_utf16(
+ __in uint32_t key,
+ __out wchar16_t * formatted_key)
+{
+ __ntapi_tt_uint_to_hex_utf16(
+ key,
+ formatted_key,
+ 16);
+}
+
+
+void __fastcall __ntapi_tt_uint32_to_hex_utf16(
+ __in uint32_t key,
+ __out wchar16_t * formatted_key)
+{
+ __ntapi_tt_uint_to_hex_utf16(
+ key,
+ formatted_key,
+ 32);
+}
+
+
+void __fastcall __ntapi_tt_uint64_to_hex_utf16(
+ __in uint64_t key,
+ __out wchar16_t * formatted_key)
+{
+ __ntapi_tt_uint_to_hex_utf16(
+ key,
+ formatted_key,
+ 64);
+}
+
+
+void __fastcall __ntapi_tt_uintptr_to_hex_utf16(
+ __in uintptr_t key,
+ __out wchar16_t * formatted_key)
+{
+ #if defined (__NT32)
+ __ntapi_tt_uint_to_hex_utf16(
+ key,
+ formatted_key,
+ 32);
+ #elif defined (__NT64)
+ __ntapi_tt_uint_to_hex_utf16(
+ key,
+ formatted_key,
+ 64);
+ #endif
+}
diff --git a/src/string/ntapi_tt_uintptr_to_hex_utf8.c b/src/string/ntapi_tt_uintptr_to_hex_utf8.c
new file mode 100644
index 0000000..b1e3141
--- /dev/null
+++ b/src/string/ntapi_tt_uintptr_to_hex_utf8.c
@@ -0,0 +1,73 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+
+static void __fastcall __ntapi_tt_uint_to_hex_utf8(
+ __in uint64_t key,
+ __out unsigned char * buffer,
+ __in unsigned bits)
+{
+ unsigned i;
+ uint32_t hex_buf[4];
+ unsigned char * hex_chars;
+ unsigned char * uch;
+ unsigned offset;
+ unsigned bytes;
+
+ /* avoid using .rdata for that one */
+ hex_buf[0] = ('3' << 24) | ('2' << 16) | ('1' << 8) | '0';
+ hex_buf[1] = ('7' << 24) | ('6' << 16) | ('5' << 8) | '4';
+ hex_buf[2] = ('B' << 24) | ('A' << 16) | ('9' << 8) | '8';
+ hex_buf[3] = ('F' << 24) | ('E' << 16) | ('D' << 8) | 'C';
+
+ uch = (unsigned char *)&key;
+ hex_chars = (unsigned char *)&hex_buf;
+
+ bytes = bits / 8;
+ offset = bits / 4;
+
+ for (i = 0; i < bytes; i++) {
+ buffer[offset - 1 - (i*2)] = hex_chars[uch[i] % 16];
+ buffer[offset - 2 - (i*2)] = hex_chars[uch[i] / 16];
+ }
+}
+
+
+void __fastcall __ntapi_tt_uint16_to_hex_utf8(
+ __in uint32_t key,
+ __out unsigned char * buffer)
+{
+ __ntapi_tt_uint_to_hex_utf8(key,buffer,16);
+}
+
+
+void __fastcall __ntapi_tt_uint32_to_hex_utf8(
+ __in uint32_t key,
+ __out unsigned char * buffer)
+{
+ __ntapi_tt_uint_to_hex_utf8(key,buffer,32);
+}
+
+
+void __fastcall __ntapi_tt_uint64_to_hex_utf8(
+ __in uint64_t key,
+ __out unsigned char * buffer)
+{
+ __ntapi_tt_uint_to_hex_utf8(key,buffer,64);
+}
+
+
+void __fastcall __ntapi_tt_uintptr_to_hex_utf8(
+ __in uintptr_t key,
+ __out unsigned char * buffer)
+{
+ #if defined (__NT32)
+ __ntapi_tt_uint_to_hex_utf8(key,buffer,32);
+ #elif defined (__NT64)
+ __ntapi_tt_uint_to_hex_utf8(key,buffer,64);
+ #endif
+}
diff --git a/src/sync/ntapi_tt_create_event.c b/src/sync/ntapi_tt_create_event.c
new file mode 100644
index 0000000..3d81938
--- /dev/null
+++ b/src/sync/ntapi_tt_create_event.c
@@ -0,0 +1,76 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_sync.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+
+static int32_t __cdecl __tt_create_event(
+ __out void ** hevent,
+ __in nt_event_type event_type,
+ __in int32_t initial_state,
+ __in uint32_t obj_attr)
+{
+ int32_t status;
+ nt_sqos sqos;
+ nt_oa oa;
+
+ /* validation */
+ if (!hevent)
+ return NT_STATUS_INVALID_PARAMETER;
+
+ /* security structure */
+ sqos.length = sizeof(sqos);
+ sqos.impersonation_level = NT_SECURITY_IMPERSONATION;
+ sqos.context_tracking_mode = NT_SECURITY_TRACKING_DYNAMIC;
+ sqos.effective_only = 1;
+
+ /* object attributes */
+ oa.len = sizeof(nt_object_attributes);
+ oa.root_dir = (void *)0;
+ oa.obj_name = (nt_unicode_string *)0;
+ oa.obj_attr = obj_attr;
+ oa.sec_desc = (nt_security_descriptor *)0;
+ oa.sec_qos = &sqos;
+
+ status = __ntapi->zw_create_event(
+ hevent,
+ NT_EVENT_ALL_ACCESS,
+ &oa,
+ event_type,
+ initial_state);
+
+ return status;
+}
+
+
+int32_t __stdcall __ntapi_tt_create_inheritable_event(
+ __out void ** hevent,
+ __in nt_event_type event_type,
+ __in int32_t initial_state)
+{
+ return __tt_create_event(
+ hevent,
+ event_type,
+ initial_state,
+ NT_OBJ_INHERIT);
+}
+
+
+int32_t __stdcall __ntapi_tt_create_private_event(
+ __out void ** hevent,
+ __in nt_event_type event_type,
+ __in int32_t initial_state)
+{
+ return __tt_create_event(
+ hevent,
+ event_type,
+ initial_state,
+ 0);
+}
diff --git a/src/sync/ntapi_tt_sync_block.c b/src/sync/ntapi_tt_sync_block.c
new file mode 100644
index 0000000..e52dd77
--- /dev/null
+++ b/src/sync/ntapi_tt_sync_block.c
@@ -0,0 +1,283 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_sync.h>
+#include <ntapi/nt_atomic.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+void __stdcall __ntapi_tt_sync_block_init(
+ __in nt_sync_block * sync_block,
+ __in uint32_t flags __optional,
+ __in int32_t srvtid __optional,
+ __in int32_t default_lock_tries __optional,
+ __in int64_t default_lock_wait __optional,
+ __in void * hsignal __optional)
+{
+ __ntapi->tt_aligned_block_memset(
+ sync_block,
+ 0,sizeof(*sync_block));
+
+ sync_block->lock_tries = default_lock_tries
+ ? default_lock_tries
+ : __NT_SYNC_BLOCK_LOCK_TRIES;
+
+ sync_block->lock_wait.quad = default_lock_wait
+ ? default_lock_wait
+ : (-1);
+
+ sync_block->flags = flags;
+ sync_block->srvtid = srvtid;
+ sync_block->hsignal = hsignal;
+
+ return;
+}
+
+
+int32_t __stdcall __ntapi_tt_sync_block_lock(
+ __in nt_sync_block * sync_block,
+ __in int32_t lock_tries __optional,
+ __in int64_t lock_wait __optional,
+ __in uint32_t * sig_flag __optional)
+{
+ int32_t status;
+ int32_t tid;
+ intptr_t lock;
+ void * hwait[2];
+ nt_timeout timeout;
+
+ /* validation */
+ if (sync_block->invalid)
+ return NT_STATUS_INVALID_HANDLE;
+
+ /* already owned? */
+ tid = pe_get_current_thread_id();
+ if (sync_block->tid == tid) return NT_STATUS_SUCCESS;
+
+ /* yield to server? */
+ if ((sync_block->flags & NT_SYNC_BLOCK_YIELD_TO_SERVER) && (tid != sync_block->srvtid)) {
+ hwait[0] = sync_block->hserver;
+ hwait[1] = sync_block->hsignal;
+
+ /* signal support */
+ if (sig_flag && *sig_flag)
+ return NT_STATUS_ALERTED;
+
+ /* wait */
+ status = __ntapi->zw_wait_for_multiple_objects(
+ 2,
+ hwait,
+ NT_WAIT_ANY,
+ NT_SYNC_NON_ALERTABLE,
+ (nt_timeout *)0);
+
+ /* signal support */
+ if (sig_flag && *sig_flag)
+ return NT_STATUS_ALERTED;
+ }
+
+ /* first try */
+ lock = at_locked_cas_32(&sync_block->tid,0,tid);
+ if (lock && !--lock_tries) return NT_STATUS_NOT_LOCKED;
+
+ /* first-time contended case? */
+ if (lock && !sync_block->hwait) {
+ status = __ntapi->tt_create_inheritable_event(
+ &hwait[0],
+ NT_NOTIFICATION_EVENT,
+ NT_EVENT_NOT_SIGNALED);
+
+ if (status) return status;
+
+ lock = at_locked_cas(
+ (intptr_t *)&sync_block->hwait,
+ 0,(intptr_t)hwait);
+
+ if (lock)
+ __ntapi->zw_close(hwait);
+
+ /* try again without a wait */
+ lock = at_locked_cas_32(&sync_block->tid,0,tid);
+ }
+
+ /* contended case? */
+ if (lock) {
+ hwait[0] = sync_block->hwait;
+ hwait[1] = sync_block->hsignal;
+
+ lock_tries = lock_tries
+ ? lock_tries
+ : sync_block->lock_tries;
+
+ timeout.quad = lock_wait
+ ? lock_wait
+ : sync_block->lock_wait.quad;
+
+ for (; lock && lock_tries; lock_tries--) {
+ /* signal support */
+ if (sig_flag && *sig_flag)
+ return NT_STATUS_ALERTED;
+
+ /* wait */
+ status = __ntapi->zw_wait_for_multiple_objects(
+ 2,
+ &sync_block->hwait,
+ NT_WAIT_ANY,
+ NT_SYNC_NON_ALERTABLE,
+ &timeout);
+
+ /* check status */
+ if ((status != NT_STATUS_TIMEOUT) && ((uint32_t)status >= NT_STATUS_WAIT_CAP))
+ return status;
+
+ /* signal support */
+ if (sig_flag && *sig_flag)
+ return NT_STATUS_ALERTED;
+
+ /* try again */
+ lock = at_locked_cas_32(&sync_block->tid,0,tid);
+ };
+ }
+
+ if (lock) return NT_STATUS_NOT_LOCKED;
+
+ /* shared section support */
+ sync_block->pid = pe_get_current_process_id();
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+int32_t __stdcall __ntapi_tt_sync_block_server_lock(
+ __in nt_sync_block * sync_block,
+ __in int32_t lock_tries __optional,
+ __in int64_t lock_wait __optional,
+ __in uint32_t * sig_flag __optional)
+{
+ int32_t status;
+
+ /* validation */
+ if (sync_block->invalid)
+ return NT_STATUS_INVALID_HANDLE;
+
+ else if (sync_block->srvtid != pe_get_current_thread_id())
+ return NT_STATUS_RESOURCE_NOT_OWNED;
+
+ /* try once without yield request */
+ status = __ntapi_tt_sync_block_lock(
+ sync_block,
+ 1,
+ lock_wait,
+ sig_flag);
+
+ if (status == NT_STATUS_SUCCESS)
+ return status;
+
+ /* hserver */
+ if (!sync_block->hserver) {
+ status = __ntapi->tt_create_inheritable_event(
+ &sync_block->hserver,
+ NT_NOTIFICATION_EVENT,
+ NT_EVENT_NOT_SIGNALED);
+
+ if (status) return status;
+ } else {
+ status = __ntapi->zw_reset_event(
+ &sync_block->hserver,
+ (int32_t *)0);
+
+ if (status) return status;
+ }
+
+ /* yield request: set */
+ sync_block->flags |= NT_SYNC_BLOCK_YIELD_TO_SERVER;
+
+ /* try again */
+ status = __ntapi_tt_sync_block_lock(
+ sync_block,
+ lock_tries,
+ lock_wait,
+ sig_flag);
+
+ /* yield request: unset */
+ sync_block->flags ^= NT_SYNC_BLOCK_YIELD_TO_SERVER;
+
+ __ntapi->zw_set_event(
+ sync_block->hserver,
+ (int32_t *)0);
+
+ /* (locking not guaranteed) */
+ return status;
+}
+
+
+int32_t __stdcall __ntapi_tt_sync_block_unlock(
+ __in nt_sync_block * sync_block)
+{
+ int64_t cmp;
+
+ if (sync_block->invalid)
+ return NT_STATUS_INVALID_HANDLE;
+
+ cmp = (int64_t)(pe_get_current_process_id()) << 32;
+ cmp += pe_get_current_thread_id();
+
+ if (cmp != at_locked_cas_64(
+ (int64_t *)&sync_block->tid,
+ cmp,0))
+ return NT_STATUS_RESOURCE_NOT_OWNED;
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+void __stdcall __ntapi_tt_sync_block_validate(
+ __in nt_sync_block * sync_block)
+{
+ at_store_32(&sync_block->invalid,0);
+
+ return;
+}
+
+
+int32_t __stdcall __ntapi_tt_sync_block_invalidate(
+ __in nt_sync_block * sync_block)
+{
+ int32_t invalid;
+
+ if (!sync_block)
+ return NT_STATUS_INVALID_PARAMETER;
+
+ invalid = at_locked_cas_32(
+ &sync_block->invalid,
+ 0,
+ 1);
+
+ if (invalid)
+ return NT_STATUS_INVALID_HANDLE;
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+int32_t __stdcall __ntapi_tt_sync_block_discard(
+ __in nt_sync_block * sync_block)
+{
+ if (!sync_block)
+ return NT_STATUS_INVALID_PARAMETER;
+
+ if (sync_block->hwait)
+ __ntapi->zw_close(sync_block->hwait);
+
+ if (sync_block->hserver)
+ __ntapi->zw_close(sync_block->hserver);
+
+ __ntapi->tt_aligned_block_memset(sync_block,-1,sizeof(*sync_block));
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/sync/ntapi_tt_wait_for_dummy_event.c b/src/sync/ntapi_tt_wait_for_dummy_event.c
new file mode 100644
index 0000000..c7680c7
--- /dev/null
+++ b/src/sync/ntapi_tt_wait_for_dummy_event.c
@@ -0,0 +1,31 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_sync.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tt_wait_for_dummy_event(void)
+{
+ /* wait forever without setting a break point and without spinning */
+
+ int32_t status;
+ void * hevent;
+
+ status = __ntapi->tt_create_inheritable_event(
+ &hevent,
+ NT_NOTIFICATION_EVENT,
+ NT_EVENT_NOT_SIGNALED);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ return __ntapi->zw_wait_for_single_object(hevent,0,0);
+
+ return status;
+}
diff --git a/src/system/ntapi_tt_get_csr_port_handle_addr_by_logic.c b/src/system/ntapi_tt_get_csr_port_handle_addr_by_logic.c
new file mode 100644
index 0000000..3f38067
--- /dev/null
+++ b/src/system/ntapi_tt_get_csr_port_handle_addr_by_logic.c
@@ -0,0 +1,197 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+/************************************************************/
+/* beginning with version 6.0, explicit thread registration */
+/* with csrss is no longer required. the code below should */
+/* work with all known versions of NT, however it will only */
+/* be used when run on the now-obsolete versions of the OS. */
+/************************************************************/
+
+/**
+ Nebbett was pretty much right in his interpretation of
+ the csrss port message; and as long as one changes
+ uint32_t to uintptr_t (especially when it comes to the
+ unknown parameters), then the structures behave as
+ expected according to his book.
+
+ SysInternals: ProcessExplorer: csrss.exe: the stack shows
+ a thread in csrsrv.dll that has CsrUnhandledExceptionFilter
+ as its start address, and ntdll!NtReplyWaitReceivePort as
+ its next function call. This suggests that csrss still
+ uses LPC (at least to some extent) for communication with
+ user processes.
+
+ Given the above, we may deduce that CsrClientCallServer
+ contains a call to ZwRequestWaitReplyPort. Assuming
+ the machine code in ntdll is as optimized as possible,
+ we may then conclude that on x86 machines, this would be
+ an E8 call using relative 32-bit addressing on both NT32
+ and NT64.
+
+ On the 32-bit variant of the operating system, the first
+ argument is passed on the stack, and is normally expressed
+ in terms of an offset from the ds register.
+
+ On the 64-bit variant of the operating system, the first
+ argument is passed in the rcx register. Here, again,
+ machine code optimization suggests that the address of
+ CsrPortHandle will be provided as a 32-bit relative address,
+ or else the code will be larger by several bytes.
+
+ The rest is based on simple logic and straight-forward
+ heuristics. Since we know the addresses of CsrClientCallSertver
+ and ZwRequestWaitReplyPort, we first find the call to the latter
+ function within the former. Once we have found that call, we
+ start going back to look for the argument-passing
+ opcode, and finally do the math to obtain the address of
+ CsrPortHandle.
+**/
+
+
+#if defined(__X86_MODEL)
+void ** __cdecl __ntapi_tt_get_csr_port_handle_addr_by_logic_i386(void)
+{
+ #define MAX_BYTES_BETWEEN_ARG1_PUSH_AND_E8_CALL 0x20
+ #define MAX_FN_BYTES_TO_TEST 0x800
+
+ typedef struct __attr_aligned__ (1) __attr_packed__ __x86_e8_call_signature {
+ unsigned char __opcode_current_e8;
+ unsigned char __addr_relative[4];
+ unsigned char __opcode_next_any;
+ } _x86_e8_call_signature;
+
+ typedef struct __attr_aligned__ (1) __attr_packed__ __x86_push_ds_signature {
+ unsigned char __push;
+ unsigned char __ds;
+ unsigned char __push_ds_arg;
+ } _x86_push_ds_signature;
+
+ unsigned char * ptr_test;
+ _x86_e8_call_signature * ptr_e8_call;
+ _x86_push_ds_signature * ptr_push_ds;
+ int32_t offset;
+
+ /* type-punned tyrants */
+ int32_t * prelative;
+ int32_t relative;
+ uintptr_t * pport_addr;
+
+
+ /* calling a function within the same library: assume E8 call */
+ for (offset = 0; offset < MAX_FN_BYTES_TO_TEST; offset++) {
+ ptr_test = (unsigned char *)__ntapi->csr_client_call_server
+ + offset;
+
+ if (*ptr_test == 0xE8) {
+ ptr_e8_call = (_x86_e8_call_signature *)ptr_test;
+
+ /* make our type-punned tyrant compiler happy */
+ prelative = (int32_t *)&(ptr_e8_call->__addr_relative);
+ relative = *prelative;
+
+ /* are we calling ZwRequestWaitReplyPort? */
+ if ((uintptr_t)(__ntapi->zw_request_wait_reply_port) ==
+ (uintptr_t)&(ptr_e8_call->__opcode_next_any)
+ + relative) {
+ /* assume ds relative address for arg1, go back to find it */
+ for (offset = 0; offset < MAX_BYTES_BETWEEN_ARG1_PUSH_AND_E8_CALL; offset++) {
+ ptr_push_ds = (_x86_push_ds_signature *)((uintptr_t)ptr_e8_call - offset);
+
+ if ((ptr_push_ds->__push == 0xFF) &&
+ (ptr_push_ds->__ds == 0x35)) {
+ /* bingo */
+ /* make our type-punned tyrant compiler happy */
+ pport_addr = (uintptr_t *)&(ptr_push_ds->__push_ds_arg);
+
+ /* all done */
+ return *(void ***)pport_addr;
+ }
+ }
+ }
+ }
+ }
+
+ /* CsrPortHandle not found */
+ return (void **)0;
+}
+#endif
+
+
+#if defined(__X86_64_MODEL)
+void ** __ntapi_tt_get_csr_port_handle_addr_by_logic_x86_64(void)
+{
+ #define MAX_BYTES_BETWEEN_ARG1_PUSH_AND_E8_CALL 0x20
+ #define MAX_FN_BYTES_TO_TEST 0x800
+
+ typedef struct __attr_aligned__ (1) __attr_packed__ __x86_e8_call_signature {
+ unsigned char __opcode_current_e8;
+ unsigned char __addr_relative[4];
+ unsigned char __opcode_next_any;
+ } _x86_e8_call_signature;
+
+ typedef struct __attr_aligned__ (1) __attr_packed__ __x86_move_rcx_rel_signature {
+ unsigned char __move;
+ unsigned char __rcx;
+ unsigned char __relative;
+ unsigned char __arg_32_relative[4];
+ unsigned char __opcode_next_any;
+ } _x86_move_rcx_rel_signature;
+
+ unsigned char * ptr_test;
+ _x86_e8_call_signature * ptr_e8_call;
+ _x86_move_rcx_rel_signature * ptr_move_rcx_rel;
+ int32_t offset;
+ int32_t relative;
+ int32_t * prelative; /* for type-punned tyrants */
+
+
+ /* calling a function within the same library: assume E8 call and 32-bit relative addressing */
+ for (offset = 0; offset < MAX_FN_BYTES_TO_TEST; offset++) {
+ ptr_test = (unsigned char *)__ntapi->csr_client_call_server
+ + offset;
+
+ if (*ptr_test == 0xE8) {
+ ptr_e8_call = (_x86_e8_call_signature *)ptr_test;
+
+ /* please our type-punned tyrant compiler */
+ prelative = (int32_t *)&(ptr_e8_call->__addr_relative);
+ relative = *prelative;
+
+ /* are we calling ZwRequestWaitReplyPort? */
+ /* comparing, not writing; ignore type-punned msgs. */
+ if ((uintptr_t)(__ntapi->zw_request_wait_reply_port) ==
+ (uintptr_t)&(ptr_e8_call->__opcode_next_any)
+ + relative) {
+ /* arg1 must be passed in rcx, so go back to find it */
+ for (offset = 0; offset < MAX_BYTES_BETWEEN_ARG1_PUSH_AND_E8_CALL; offset++) {
+ ptr_move_rcx_rel = (_x86_move_rcx_rel_signature *)((uintptr_t)ptr_e8_call - offset);
+
+ if ((ptr_move_rcx_rel->__move == 0x48) &&
+ (ptr_move_rcx_rel->__rcx == 0x8b) &&
+ (ptr_move_rcx_rel->__relative == 0x0d))
+ /* bingo */
+ /* make our type-punned tyrant compiler happy */
+ prelative = (int32_t *)&(ptr_move_rcx_rel->__arg_32_relative);
+ relative = *prelative;
+
+ /* all done */
+ return (void **)(
+ (uintptr_t)&ptr_move_rcx_rel->__opcode_next_any
+ + relative);
+ }
+ }
+ }
+ }
+
+ /* CsrPortHandle not found */
+ return (void **)0;
+}
+#endif
diff --git a/src/system/ntapi_tt_get_system_directory.c b/src/system/ntapi_tt_get_system_directory.c
new file mode 100644
index 0000000..28b9745
--- /dev/null
+++ b/src/system/ntapi_tt_get_system_directory.c
@@ -0,0 +1,257 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <pemagine/pemagine.h>
+#include <ntapi/nt_sysinfo.h>
+#include <ntapi/nt_memory.h>
+#include <ntapi/ntapi.h>
+#include <ntapi/nt_atomic.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tt_get_system_directory_native_path(
+ __out nt_mem_sec_name * buffer,
+ __in uint32_t buffer_size,
+ __in wchar16_t * base_name,
+ __in uint32_t base_name_size,
+ __out nt_unicode_string * nt_path __optional)
+{
+ int32_t status;
+ wchar16_t * wch_src;
+ wchar16_t * wch_dst;
+ wchar16_t * wch_cap;
+ size_t maxlen_saved;
+ size_t info_size;
+
+ /* validation */
+ if (!buffer || !buffer_size)
+ return NT_STATUS_BUFFER_TOO_SMALL;
+ else if (base_name && !base_name_size)
+ return NT_STATUS_INVALID_PARAMETER_MIX;
+
+ /* init buffer */
+ buffer->section_name.strlen = 0;
+ buffer->section_name.maxlen = (uint16_t)(buffer_size - sizeof(nt_unicode_string));
+ buffer->section_name.buffer = buffer->section_name_buffer;
+
+ maxlen_saved = buffer->section_name.maxlen;
+ info_size = 0;
+
+ status = __ntapi->zw_query_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ pe_get_ntdll_module_handle(),
+ NT_MEMORY_SECTION_NAME,
+ buffer,
+ buffer_size,
+ &info_size);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ /* find directory portion */
+ wch_dst = buffer->section_name.buffer + (buffer->section_name.strlen / sizeof(wchar16_t));
+ wch_dst--;
+
+ while ((*wch_dst != '\\') && (wch_dst > buffer->section_name.buffer))
+ wch_dst--;
+
+ if (wch_dst == buffer->section_name.buffer)
+ return NT_STATUS_INTERNAL_ERROR;
+
+ /* base_name */
+ if (base_name) {
+ wch_dst++;
+ wch_src = base_name;
+ wch_cap = (wchar16_t *)((uintptr_t)wch_dst + base_name_size);
+
+ if ((uintptr_t)wch_cap - (uintptr_t)(buffer->section_name.buffer) > maxlen_saved)
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ while (wch_dst < wch_cap) {
+ *wch_dst = *wch_src;
+ wch_dst++;
+ wch_src++;
+ }
+ }
+
+ /* null termination */
+ *wch_dst = 0;
+
+ /* nt_path */
+ if (nt_path)
+ __ntapi->rtl_init_unicode_string(
+ nt_path,
+ buffer->section_name.buffer);
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+int32_t __stdcall __ntapi_tt_get_system_directory_handle(
+ __out void ** hsysdir,
+ __out nt_mem_sec_name * buffer __optional,
+ __in uint32_t buffer_size __optional)
+{
+ int32_t status;
+ nt_oa oa;
+ nt_iosb iosb;
+ nt_unicode_string path;
+ char _buffer[256];
+
+ /* validation */
+ if (!hsysdir)
+ return NT_STATUS_INVALID_PARAMETER_1;
+ else if (buffer_size && buffer_size < 0x20)
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ /* buffer */
+ if (!buffer) {
+ buffer = (nt_mem_sec_name *)_buffer;
+ buffer_size = sizeof(_buffer);
+ __ntapi->tt_aligned_block_memset(buffer,0,sizeof(buffer));
+ }
+
+ /* sysdir path */
+ status = __ntapi_tt_get_system_directory_native_path(
+ buffer,
+ buffer_size,
+ (wchar16_t *)0,
+ 0,
+ &path);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ /* oa */
+ oa.len = sizeof(nt_oa);
+ oa.root_dir = (void *)0;
+ oa.obj_name = &path;
+ oa.obj_attr = 0;
+ oa.sec_desc = 0;
+ oa.sec_qos = 0;
+
+ /* open file/folder */
+ status = __ntapi->zw_open_file(
+ hsysdir,
+ NT_SEC_SYNCHRONIZE | NT_FILE_READ_ATTRIBUTES | NT_FILE_READ_ACCESS,
+ &oa,
+ &iosb,
+ NT_FILE_SHARE_READ | NT_FILE_SHARE_WRITE,
+ NT_FILE_DIRECTORY_FILE | NT_FILE_SYNCHRONOUS_IO_ALERT);
+
+ return status;
+}
+
+
+int32_t __stdcall __ntapi_tt_get_system_directory_dos_path(
+ __in void * hsysdir __optional,
+ __out wchar16_t * buffer,
+ __in uint32_t buffer_size,
+ __in wchar16_t * base_name,
+ __in uint32_t base_name_size,
+ __out nt_unicode_string * nt_path __optional)
+{
+ int32_t status;
+ nt_statfs statfs;
+ wchar16_t * wch;
+ wchar16_t * wch_src;
+ wchar16_t * wch_cap;
+ nt_iosb iosb;
+ nt_fni * fni;
+ uint32_t fni_length;
+
+ /* validation */
+ if (!buffer)
+ return NT_STATUS_INVALID_PARAMETER_2;
+
+ /* hsysdir */
+ if (!hsysdir) {
+ status = __ntapi_tt_get_system_directory_handle(
+ &hsysdir,
+ (nt_mem_sec_name *)buffer,
+ buffer_size);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+ }
+
+ /* statfs */
+ status = __ntapi->tt_statfs(
+ hsysdir,
+ (void *)0,
+ (nt_unicode_string *)0,
+ &statfs,
+ (uintptr_t *)buffer,
+ buffer_size,
+ NT_STATFS_DOS_DRIVE_LETTER);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ /* dos path name (always shorter than the native path, so buffer_size must be ok) */
+ wch = buffer;
+ *wch = '\\'; wch++;
+ *wch = '?'; wch++;
+ *wch = '?'; wch++;
+ *wch = '\\'; wch++;
+ *wch = statfs.nt_drive_letter; wch++;
+ *wch = ':'; wch++;
+
+ /* alignment */
+ fni = (nt_fni *)((uintptr_t)buffer + 0x10);
+
+ status = __ntapi->zw_query_information_file(
+ hsysdir,
+ &iosb,
+ fni,
+ buffer_size - 8 * sizeof(wchar16_t),
+ NT_FILE_NAME_INFORMATION);
+
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ /* fni->file_name_length: save */
+ fni_length = fni->file_name_length;
+
+ /* overwrite */
+ wch_src = fni->file_name;
+ wch_cap = (wchar16_t *)((uintptr_t)wch_src + fni_length);
+
+ while (wch_src < wch_cap) {
+ *wch = *wch_src;
+ wch++;
+ wch_src++;
+ }
+
+ /* ultimate path separator */
+ *wch = '\\'; wch++;
+
+ /* base_name */
+ if (base_name) {
+ wch_src = base_name;
+ wch_cap = (wchar16_t *)((uintptr_t)wch + base_name_size);
+
+ if ((uintptr_t)wch_cap - (uintptr_t)buffer - sizeof(wchar16_t) > buffer_size)
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ while (wch < wch_cap) {
+ *wch = *wch_src;
+ wch++;
+ wch_src++;
+ }
+ }
+
+ /* null termination */
+ *wch = 0;
+
+ /* nt_path */
+ if (nt_path)
+ __ntapi->rtl_init_unicode_string(
+ nt_path,
+ buffer);
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/system/ntapi_tt_get_system_info_snapshot.c b/src/system/ntapi_tt_get_system_info_snapshot.c
new file mode 100644
index 0000000..bfe2978
--- /dev/null
+++ b/src/system/ntapi_tt_get_system_info_snapshot.c
@@ -0,0 +1,89 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <pemagine/pemagine.h>
+#include <ntapi/nt_sysinfo.h>
+#include <ntapi/nt_memory.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tt_get_system_info_snapshot(
+ __in_out nt_system_information_snapshot * sys_info_snapshot)
+{
+ int32_t status;
+
+ /* pre-allocated buffer? */
+ if (sys_info_snapshot->buffer)
+ status = __ntapi->zw_query_system_information(
+ sys_info_snapshot->sys_info_class,
+ sys_info_snapshot->buffer,
+ sys_info_snapshot->max_len,
+ &sys_info_snapshot->info_len);
+ else {
+ /* set initial buffer size */
+ sys_info_snapshot->max_len = NT_ALLOCATION_GRANULARITY;
+
+ /* allocate initial buffer */
+ status = __ntapi->zw_allocate_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ (void **)&sys_info_snapshot->buffer,
+ 0,
+ &sys_info_snapshot->max_len,
+ NT_MEM_COMMIT,
+ NT_PAGE_READWRITE);
+
+ /* verification */
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ /* loop until buffer is large enough to satisfy the system */
+ while ((status = __ntapi->zw_query_system_information(
+ sys_info_snapshot->sys_info_class,
+ sys_info_snapshot->buffer,
+ sys_info_snapshot->max_len,
+ &sys_info_snapshot->info_len))
+ == NT_STATUS_INFO_LENGTH_MISMATCH) {
+
+ /* free previously allocated memory */
+ status = __ntapi->zw_free_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ (void **)&sys_info_snapshot->buffer,
+ &sys_info_snapshot->max_len,
+ NT_MEM_RELEASE);
+
+ /* verification */
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+
+ /* reset buffer and increase buffer size */
+ sys_info_snapshot->buffer = (nt_system_information_buffer *)0;
+ sys_info_snapshot->max_len += NT_ALLOCATION_GRANULARITY;
+
+ /* reallocate buffer memory */
+ status = __ntapi->zw_allocate_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ (void **)&sys_info_snapshot->buffer,
+ 0,
+ &sys_info_snapshot->max_len,
+ NT_MEM_COMMIT,
+ NT_PAGE_READWRITE);
+
+ /* verification */
+ if (status != NT_STATUS_SUCCESS)
+ return status;
+ }
+ }
+
+ /* verification */
+ if (status == NT_STATUS_SUCCESS) {
+ sys_info_snapshot->pcurrent = &sys_info_snapshot->buffer->mark;
+ return NT_STATUS_SUCCESS;
+ } else {
+ sys_info_snapshot->pcurrent = (void *)0;
+ return status;
+ }
+}
diff --git a/src/thread/ntapi_tt_create_thread.c b/src/thread/ntapi_tt_create_thread.c
new file mode 100644
index 0000000..4fbe68f
--- /dev/null
+++ b/src/thread/ntapi_tt_create_thread.c
@@ -0,0 +1,418 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <pemagine/pemagine.h>
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_memory.h>
+#include <ntapi/nt_thread.h>
+#include <ntapi/nt_process.h>
+#include <ntapi/nt_string.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+/* (no planned support of alpha processors, use constant values) */
+#define __PAGE_SIZE 0x001000
+#define __GRANULARITY 0x010000
+#define __RESERVE_ROUND_UP 0x100000
+
+static int32_t __stdcall __create_thread_fail(
+ void * hprocess,
+ void * stack_bottom,
+ size_t stack_size,
+ int32_t status)
+{
+ __ntapi->zw_free_virtual_memory(
+ hprocess,
+ &stack_bottom,
+ &stack_size,
+ NT_MEM_RELEASE);
+ return status;
+}
+
+int32_t __stdcall __ntapi_tt_create_thread(
+ __in_out nt_thread_params * params)
+{
+ int32_t status;
+ ntapi_internals * __internals;
+
+ nt_client_id cid;
+ nt_port_message_csrss_process csrss_msg;
+ nt_port_message_csrss_process * csrss_msg_1st;
+ nt_port_message_csrss_thread * csrss_msg_any;
+
+ void * stack_system_limit;
+ uint32_t protect_type_old;
+
+ nt_user_stack stack;
+ nt_thread_context context;
+ uintptr_t fsuspended;
+ uintptr_t * parg;
+
+ if (!(params->stack_size_commit))
+ return NT_STATUS_INVALID_PARAMETER;
+ else if (!(params->stack_size_reserve))
+ return NT_STATUS_INVALID_PARAMETER;
+ else if (params->ext_ctx_size > __NT_INTERNAL_PAGE_SIZE)
+ return NT_STATUS_INVALID_PARAMETER;
+ else if (params->ext_ctx_size % sizeof(intptr_t))
+ return NT_STATUS_INVALID_PARAMETER;
+ else if (params->arg && params->ext_ctx)
+ return NT_STATUS_INVALID_PARAMETER_MIX;
+ else if (params->ext_ctx && !params->ext_ctx_size)
+ return NT_STATUS_INVALID_PARAMETER_MIX;
+
+ /* init */
+ __internals = __ntapi_internals();
+ params->stack_size_commit = __NT_ROUND_UP_TO_POWER_OF_2(params->stack_size_commit+params->ext_ctx_size, __PAGE_SIZE);
+ params->stack_size_reserve = __NT_ROUND_UP_TO_POWER_OF_2(params->stack_size_reserve,__GRANULARITY);
+
+ /* compare, round-up as needed */
+ if (params->stack_size_commit >= params->stack_size_reserve)
+ params->stack_size_reserve = __NT_ROUND_UP_TO_POWER_OF_2(params->stack_size_commit,__RESERVE_ROUND_UP);
+
+ /**
+ *
+ * --------- BASE ----------
+ *
+ * ---- (COMMITED AREA) ----
+ *
+ * --------- LIMIT ---------
+ *
+ * ------ GUARD PAGE -------
+ *
+ * ------ ACTUAL LIMIT -----
+ *
+ * ---- (RESERVED AREA) ----
+ *
+ * -------- BOTTOM ---------
+ *
+ **/
+
+ /* stack structure: unused fields */
+ stack.fixed_stack_base = (void *)0;
+ stack.fixed_stack_limit = (void *)0;
+
+ /* first we reserve */
+ stack.expandable_stack_bottom = (void *)0;
+ status = __ntapi->zw_allocate_virtual_memory(
+ params->hprocess,
+ &stack.expandable_stack_bottom,
+ params->stack_zero_bits,
+ ¶ms->stack_size_reserve,
+ NT_MEM_RESERVE,
+ NT_PAGE_READWRITE);
+
+ if (status) return status;
+
+ /* calculate base and limit */
+ stack.expandable_stack_base =
+ (void *)((intptr_t)stack.expandable_stack_bottom
+ + params->stack_size_reserve);
+
+ stack.expandable_stack_limit =
+ (void *)((intptr_t)stack.expandable_stack_base
+ - params->stack_size_commit);
+
+ /* guard page */
+ params->stack_size_commit += __PAGE_SIZE;
+ stack_system_limit =
+ (void *)((intptr_t)stack.expandable_stack_base
+ - params->stack_size_commit);
+
+ /* then we commit */
+ status = __ntapi->zw_allocate_virtual_memory(
+ params->hprocess,
+ &stack_system_limit,
+ 0,
+ ¶ms->stack_size_commit,
+ NT_MEM_COMMIT,
+ NT_PAGE_READWRITE);
+
+ if (status) return __create_thread_fail(
+ params->hprocess,
+ stack.expandable_stack_bottom,
+ params->stack_size_reserve,
+ status);
+
+ /* finally we protect the guard page */
+ params->stack_size_commit = __PAGE_SIZE;
+ status = __ntapi->zw_protect_virtual_memory(
+ params->hprocess,
+ &stack_system_limit,
+ ¶ms->stack_size_commit,
+ NT_PAGE_READWRITE | NT_MEM_PAGE_GUARD,
+ &protect_type_old);
+
+ if (status) return __create_thread_fail(
+ params->hprocess,
+ stack.expandable_stack_bottom,
+ params->stack_size_reserve,
+ status);
+
+ /* context */
+ if (!params->reg_context) {
+ params->reg_context = &context;
+ __ntapi->tt_aligned_block_memset(&context,0,sizeof(nt_thread_context));
+ __INIT_CONTEXT(context);
+ context.INSTRUCTION_POINTER_REGISTER = (uintptr_t)params->start;
+ context.STACK_POINTER_REGISTER = (uintptr_t)(stack.expandable_stack_base)
+ - sizeof(intptr_t);
+ }
+
+
+
+
+
+
+
+/*****************************************************************************/
+/*-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-*/
+/* */
+/* */
+/* INNOVATION IN THE FIELD OF MULTI-THREADED COMPUTER PROGRAMMING */
+/* */
+/* A "RAPUNZEL" TOP-OF-STACK, VARIABLE-SIZE ENTRY-ROUTINE CONTEXT */
+/* */
+/* COPYRIGHT (C) 2013,2014,2015 ZVI GILBOA */
+/* */
+/* */
+/* */
+/* Laß mir dein Haar herunter.« */
+/**/ if (params->ext_ctx) { /**/
+/**/ context.STACK_POINTER_REGISTER -= params->ext_ctx_size; /**/
+/**/ params->arg = (void *)context.STACK_POINTER_REGISTER; /**/
+/**/ /**/
+/**/ if (params->creation_flags & NT_CREATE_LOCAL_THREAD) /**/
+/**/ __ntapi->tt_aligned_block_memcpy( /**/
+/**/ (uintptr_t *)params->arg, /**/
+/**/ (uintptr_t *)params->ext_ctx, /**/
+/**/ params->ext_ctx_size); /**/
+/**/ else { /**/
+/**/ status = __ntapi->zw_write_virtual_memory( /**/
+/**/ params->hprocess, /**/
+/**/ params->arg, /**/
+/**/ (char *)params->ext_ctx, /**/
+/**/ params->ext_ctx_size, /**/
+/**/ 0); /**/
+/**/ /**/
+/**/ if (status) return __create_thread_fail( /**/
+/**/ params->hprocess, /**/
+/**/ stack.expandable_stack_bottom, /**/
+/**/ params->stack_size_reserve, /**/
+/**/ status); /**/
+/**/ } /**/
+/**/ } /**/
+/**/ /**/
+/**/ /**/
+/**/ /**/
+/* entry-routine argument address and stack pointer adjustment */
+/**/ if (sizeof(intptr_t) == 4) { /**/
+/**/ context.STACK_POINTER_REGISTER -= sizeof(intptr_t); /**/
+/**/ parg = (uintptr_t *)context.STACK_POINTER_REGISTER; /**/
+/**/ } else /**/
+/**/ parg = &context.FAST_CALL_ARG0; /**/
+/**/ /**/
+/**/ /**/
+/* write entry-routine argument */
+/**/ if ((sizeof(size_t) == 8) /**/
+/**/ || (params->creation_flags&NT_CREATE_LOCAL_THREAD))/**/
+/**/ *parg = (uintptr_t)params->arg; /**/
+/**/ else { /**/
+/**/ status = __ntapi->zw_write_virtual_memory( /**/
+/**/ params->hprocess, /**/
+/**/ parg, /**/
+/**/ (char *)¶ms->arg, /**/
+/**/ sizeof(uintptr_t), /**/
+/**/ 0); /**/
+/**/ /**/
+/**/ if (status) return __create_thread_fail( /**/
+/**/ params->hprocess, /**/
+/**/ stack.expandable_stack_bottom, /**/
+/**/ params->stack_size_reserve, /**/
+/**/ status); /**/
+/**/ } /**/
+/**/ /**/
+/**/ /**/
+/*-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-*/
+/*****************************************************************************/
+
+
+
+
+
+
+
+
+
+
+
+ /* create thread */
+ if ((!__ntapi->zw_create_user_process) | (params->creation_flags & NT_CREATE_SUSPENDED))
+ fsuspended = 1;
+ else
+ fsuspended = 0;
+
+ status = __ntapi->zw_create_thread(
+ ¶ms->hthread,
+ NT_THREAD_ALL_ACCESS,
+ params->obj_attr,
+ params->hprocess,
+ &cid,
+ params->reg_context,
+ &stack,
+ fsuspended);
+
+ if (status) return __create_thread_fail(
+ params->hprocess,
+ stack.expandable_stack_bottom,
+ params->stack_size_reserve,
+ status);
+
+ /* for os versions prior to hasta la */
+ if (!__ntapi->zw_create_user_process) {
+ __ntapi->tt_aligned_block_memset(&csrss_msg,0,sizeof(csrss_msg));
+
+ if (params->creation_flags & NT_CREATE_FIRST_THREAD_OF_PROCESS) {
+ /* nt_port_message_csrss_process is the larger structure */
+ csrss_msg_1st = &csrss_msg;
+
+ csrss_msg_1st->header.data_size = sizeof(nt_port_message_csrss_process) - sizeof(nt_port_message);
+ csrss_msg_1st->header.msg_size = sizeof(nt_port_message_csrss_process);
+ csrss_msg_1st->opcode = 0x10000;
+ csrss_msg_1st->hprocess = params->hprocess;
+ csrss_msg_1st->hthread = params->hthread;
+ csrss_msg_1st->unique_process_id = cid.process_id;
+ csrss_msg_1st->unique_thread_id = cid.thread_id;
+ } else {
+ /* nt_port_message_csrss_thread is the smaller structure */
+ csrss_msg_any = (nt_port_message_csrss_thread *)&csrss_msg;
+
+ csrss_msg_any->header.data_size = sizeof(nt_port_message_csrss_thread) - sizeof(nt_port_message);
+ csrss_msg_any->header.msg_size = sizeof(nt_port_message_csrss_thread);
+ csrss_msg_any->opcode = 0x10001;
+ csrss_msg_any->hthread = params->hthread;
+ csrss_msg_any->unique_process_id = cid.process_id;
+ csrss_msg_any->unique_thread_id = cid.thread_id;
+ }
+
+ /* send csrss a new-thread notification */
+ if (__internals->csr_port_handle_addr) {
+ status = __ntapi->zw_request_wait_reply_port(
+ *__internals->csr_port_handle_addr,
+ &csrss_msg,&csrss_msg);
+ }
+
+ /* output csrss_status to caller */
+ params->csrss_status = status
+ ? status
+ : csrss_msg.status;
+ }
+
+ /* resume thread, close handle as needed */
+ if (fsuspended && !(params->creation_flags & NT_CREATE_SUSPENDED))
+ status = __ntapi->zw_resume_thread(params->hthread,0);
+
+ if (params->creation_flags & NT_CLOSE_THREAD_HANDLE)
+ __ntapi->zw_close(params->hthread);
+
+ /* and finally */
+ params->thread_id = (uint32_t)cid.thread_id;
+ return NT_STATUS_SUCCESS;
+}
+
+
+int32_t __stdcall __ntapi_tt_create_local_thread(
+ __in_out nt_thread_params * params)
+{
+ void * image_base;
+ struct pe_stack_heap_info stack_heap_info;
+ nt_client_id cid;
+ nt_object_attributes oa;
+ nt_status status;
+
+ /* oa init */
+ oa.len = sizeof(oa);
+ oa.root_dir = (void *)0;
+ oa.obj_name = (nt_unicode_string *)0;
+ oa.obj_attr = 0;
+ oa.sec_desc = (nt_sd *)0;
+ oa.sec_qos = (nt_sqos *)0;
+
+ /* init cid */
+ cid.process_id = pe_get_current_process_id();
+ cid.thread_id = pe_get_current_thread_id();
+
+ /* obtain a handle to our own process */
+ /* TODO: use cached handle, no close */
+ status = __ntapi->zw_open_process(
+ ¶ms->hprocess,
+ NT_PROCESS_ALL_ACCESS,
+ &oa,
+ &cid);
+
+ if (status) return status;
+
+ /* retrieve the stack defaults as needed */
+ if (!(params->stack_size_commit && params->stack_size_reserve) && !(params->stack_info)) {
+ /* image_base*/
+ image_base = pe_get_first_module_handle();
+
+ if (!(intptr_t)image_base)
+ return NT_STATUS_INVALID_IMPORT_OF_NON_DLL;
+
+ status = pe_get_image_stack_heap_info(
+ image_base,
+ &stack_heap_info);
+
+ if (status)
+ return NT_STATUS_INVALID_IMAGE_FORMAT;
+
+ /* stack_size_commit */
+ if (!params->stack_size_commit)
+ params->stack_size_commit = stack_heap_info.size_of_stack_commit;
+
+ /* stack_size_reserve */
+ if (!params->stack_size_reserve)
+ params->stack_size_reserve = stack_heap_info.size_of_stack_reserve;
+
+ if (!(params->stack_size_commit && params->stack_size_reserve))
+ return NT_STATUS_INVALID_IMAGE_FORMAT;
+ }
+
+ params->creation_flags |= NT_CREATE_LOCAL_THREAD;
+ status = __ntapi_tt_create_thread(params);
+
+ /* TODO: use cached handle, no close */
+ __ntapi->zw_close(params->hprocess);
+ return status;
+}
+
+
+int32_t __stdcall __ntapi_tt_create_remote_thread(
+ __in_out nt_thread_params * params)
+{
+ return __ntapi_tt_create_thread(params);
+}
+
+
+void * __cdecl __ntapi_csr_port_handle(nt_status * pstatus)
+{
+ ntapi_internals * __internals;
+
+ __internals = __ntapi_internals();
+
+ if (__internals->csr_port_handle_addr) {
+ if (pstatus)
+ *pstatus = NT_STATUS_SUCCESS;
+ return *__internals->csr_port_handle_addr;
+ } else {
+ if (pstatus)
+ *pstatus = NT_STATUS_UNSUCCESSFUL;
+ return (void *)0;
+ }
+}
diff --git a/src/tty/ntapi_tty_client_process_register.c b/src/tty/ntapi_tty_client_process_register.c
new file mode 100644
index 0000000..935cf1e
--- /dev/null
+++ b/src/tty/ntapi_tty_client_process_register.c
@@ -0,0 +1,37 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tty_client_process_register(
+ __in void * hport,
+ __in uintptr_t process_id,
+ __in uintptr_t thread_id,
+ __in uintptr_t flags,
+ __in nt_large_integer * reserved)
+{
+ nt_status status;
+ nt_tty_register_msg msg;
+
+ __ntapi->tt_aligned_block_memset(
+ &msg,0,sizeof(msg));
+
+ msg.header.msg_type = NT_LPC_NEW_MESSAGE;
+ msg.header.data_size = sizeof(msg.data);
+ msg.header.msg_size = sizeof(msg);
+ msg.data.ttyinfo.opcode = NT_TTY_CLIENT_PROCESS_REGISTER;
+
+ msg.data.reginfo.process_id = process_id;
+ msg.data.reginfo.thread_id = thread_id;
+ msg.data.reginfo.flags = flags;
+
+ if ((status = __ntapi->zw_request_wait_reply_port(hport,&msg,&msg)))
+ return status;
+
+ return msg.data.ttyinfo.status;
+}
diff --git a/src/tty/ntapi_tty_client_session_query.c b/src/tty/ntapi_tty_client_session_query.c
new file mode 100644
index 0000000..1d0dbe8
--- /dev/null
+++ b/src/tty/ntapi_tty_client_session_query.c
@@ -0,0 +1,40 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_tty.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tty_client_session_query(
+ __in void * hport,
+ __out nt_tty_session_info * sessioninfo)
+{
+ int32_t status;
+ nt_tty_session_msg msg;
+
+ hport = hport ? hport : __ntapi_internals()->hport_tty_session;
+
+ __ntapi->tt_aligned_block_memset(
+ &msg,0,sizeof(msg));
+
+ msg.header.msg_type = NT_LPC_NEW_MESSAGE;
+ msg.header.data_size = sizeof(msg.data);
+ msg.header.msg_size = sizeof(msg);
+ msg.data.ttyinfo.opcode = NT_TTY_CLIENT_SESSION_QUERY;
+
+ if ((status = __ntapi->zw_request_wait_reply_port(hport,&msg,&msg)))
+ return status;
+ else if (msg.data.ttyinfo.status)
+ return msg.data.ttyinfo.status;
+
+ sessioninfo->pid = msg.data.sessioninfo.pid;
+ sessioninfo->pgid = msg.data.sessioninfo.pgid;
+ sessioninfo->sid = msg.data.sessioninfo.sid;
+ sessioninfo->reserved = msg.data.sessioninfo.reserved;
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/tty/ntapi_tty_client_session_set.c b/src/tty/ntapi_tty_client_session_set.c
new file mode 100644
index 0000000..600fd5e
--- /dev/null
+++ b/src/tty/ntapi_tty_client_session_set.c
@@ -0,0 +1,38 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_tty.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tty_client_session_set(
+ __in void * hport,
+ __in nt_tty_session_info * sessioninfo)
+{
+ int32_t status;
+ nt_tty_session_msg msg;
+
+ hport = hport ? hport : __ntapi_internals()->hport_tty_session;
+
+ __ntapi->tt_aligned_block_memset(
+ &msg,0,sizeof(msg));
+
+ msg.header.msg_type = NT_LPC_NEW_MESSAGE;
+ msg.header.data_size = sizeof(msg.data);
+ msg.header.msg_size = sizeof(msg);
+ msg.data.ttyinfo.opcode = NT_TTY_CLIENT_SESSION_SET;
+
+ msg.data.sessioninfo.pid = sessioninfo->pid;
+ msg.data.sessioninfo.pgid = sessioninfo->pgid;
+ msg.data.sessioninfo.sid = sessioninfo->sid;
+ msg.data.sessioninfo.reserved = sessioninfo->reserved;
+
+ if ((status = __ntapi->zw_request_wait_reply_port(hport,&msg,&msg)))
+ return status;
+
+ return msg.data.ttyinfo.status;
+}
diff --git a/src/tty/ntapi_tty_connect.c b/src/tty/ntapi_tty_connect.c
new file mode 100644
index 0000000..4ef198c
--- /dev/null
+++ b/src/tty/ntapi_tty_connect.c
@@ -0,0 +1,47 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_string.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tty_connect(
+ __out void ** hport,
+ __in wchar16_t * tty_port_name,
+ __in int32_t impersonation_level)
+{
+ nt_object_attributes oa;
+ nt_unicode_string name;
+ nt_security_quality_of_service sqos;
+
+ __ntapi->tt_init_unicode_string_from_utf16(
+ &name,tty_port_name);
+
+ sqos.length = sizeof(sqos);
+ sqos.impersonation_level = impersonation_level;
+ sqos.context_tracking_mode = NT_SECURITY_TRACKING_DYNAMIC;
+ sqos.effective_only = 1;
+
+ oa.len = sizeof(oa);
+ oa.root_dir = (void *)0;
+ oa.obj_name = &name;
+ oa.obj_attr = 0;
+ oa.sec_desc = (nt_security_descriptor *)0;
+ oa.sec_qos = &sqos;
+
+ return __ntapi->zw_connect_port(
+ hport,
+ &name,
+ &sqos,
+ (nt_port_section_write *)0,
+ (nt_port_section_read *)0,
+ (uint32_t *)0,
+ (void *)0,
+ (uint32_t *)0);
+}
diff --git a/src/tty/ntapi_tty_create_session.c b/src/tty/ntapi_tty_create_session.c
new file mode 100644
index 0000000..176b2fb
--- /dev/null
+++ b/src/tty/ntapi_tty_create_session.c
@@ -0,0 +1,166 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+static int32_t __fastcall __tty_create_session_return(
+ nt_create_process_params * params,
+ int32_t status)
+{
+ if (status)
+ __ntapi->zw_terminate_process(
+ params->hprocess,
+ NT_STATUS_UNEXPECTED_IO_ERROR);
+
+ __ntapi->zw_close(params->hprocess);
+ __ntapi->zw_close(params->hthread);
+
+ return status;
+}
+
+int32_t __stdcall __ntapi_tty_create_session(
+ __out void ** hport,
+ __out nt_port_name * port_name,
+ __in nt_tty_session_type type,
+ __in const nt_guid * guid __optional,
+ __in wchar16_t * image_name __optional)
+{
+ nt_status status;
+ ntapi_internals * __internals;
+
+ nt_port_attr port_attr;
+ nt_runtime_data ssattr;
+ nt_runtime_data_block rtblock;
+ nt_create_process_params params;
+
+ wchar16_t __attr_aligned__(8) __tty_image_name_fallback[] = {
+ '\\','?','?','\\',
+ 'C',':',
+ '\\','m','i','d','i','p','i','x',
+ '\\','b','i','n',
+ '\\','n','t','c','t','t','y',
+ '.','e','x','e',
+ 0};
+
+ /* init */
+ __internals = __ntapi_internals();
+
+ __ntapi->tt_aligned_block_memset(
+ &port_attr,0,sizeof(port_attr));
+
+ switch (type) {
+ case NT_TTY_SESSION_PRIMARY:
+ port_attr.type = NT_PORT_TYPE_SUBSYSTEM;
+ port_attr.subtype = NT_PORT_SUBTYPE_DEFAULT;
+
+ if (!hport)
+ hport = &__internals->hport_tty_session;
+
+ if (!port_name)
+ port_name = __internals->subsystem;
+
+ if (!image_name)
+ image_name = __tty_image_name_fallback;
+
+ break;
+
+ case NT_TTY_SESSION_PRIVATE:
+ port_attr.type = NT_PORT_TYPE_SUBSYSTEM;
+ port_attr.subtype = NT_PORT_SUBTYPE_PRIVATE;
+ break;
+
+ default:
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
+ /* port guid */
+ if (guid)
+ __ntapi->tt_guid_copy(
+ &port_attr.guid,
+ guid);
+ else
+ __ntapi->tt_port_guid_from_type(
+ &port_attr.guid,
+ port_attr.type,
+ port_attr.subtype);
+
+ /* port keys */
+ if ((status = __ntapi->tt_port_generate_keys(&port_attr.keys)))
+ return status;
+
+ /* port name */
+ __ntapi->tt_port_name_from_attributes(
+ port_name,
+ &port_attr);
+
+ /* subsystem attributes */
+ __ntapi->tt_aligned_block_memset(
+ &ssattr,0,sizeof(ssattr));
+
+ ssattr.srv_type = port_attr.type;
+ ssattr.srv_subtype = port_attr.subtype;
+ ssattr.srv_keys[0] = port_attr.keys.key[0];
+ ssattr.srv_keys[1] = port_attr.keys.key[1];
+ ssattr.srv_keys[2] = port_attr.keys.key[2];
+ ssattr.srv_keys[3] = port_attr.keys.key[3];
+ ssattr.srv_keys[4] = port_attr.keys.key[4];
+ ssattr.srv_keys[5] = port_attr.keys.key[5];
+
+ __ntapi->tt_guid_copy(
+ &ssattr.srv_guid,
+ &port_attr.guid);
+
+ if ((status = __ntapi->tt_create_private_event(
+ &ssattr.srv_ready,
+ NT_SYNCHRONIZATION_EVENT,
+ NT_EVENT_NOT_SIGNALED)))
+ return status;
+
+ /* create subsystem process */
+ rtblock.addr = &ssattr;
+ rtblock.size = sizeof(ssattr);
+ rtblock.remote_addr = 0;
+ rtblock.remote_size = 0;
+ rtblock.flags = NT_RUNTIME_DATA_DUPLICATE_SESSION_HANDLES;
+
+ __ntapi->tt_aligned_block_memset(
+ ¶ms,0,sizeof(params));
+
+ params.image_name = image_name;
+ params.rtblock = &rtblock;
+
+ if ((status = __ntapi->tt_create_native_process(¶ms)))
+ return status;
+
+ if ((status = __ntapi->zw_wait_for_single_object(
+ ssattr.srv_ready,
+ NT_SYNC_NON_ALERTABLE,
+ 0)))
+ return __tty_create_session_return(¶ms,status);
+
+ /* connect to subsystem */
+ if ((status = __ntapi->tty_connect(
+ hport,
+ &port_name->base_named_objects[0],
+ NT_SECURITY_IMPERSONATION)))
+ return __tty_create_session_return(¶ms,status);
+
+ /* finalize primary session */
+ if (type == NT_TTY_SESSION_PRIMARY) {
+ if (hport != &__internals->hport_tty_session)
+ __internals->hport_tty_session = *hport;
+
+ if (port_name != __internals->subsystem)
+ __ntapi->tt_memcpy_utf16(
+ __internals->subsystem->base_named_objects,
+ port_name->base_named_objects,
+ sizeof(*port_name));
+ };
+
+ return __tty_create_session_return(¶ms,NT_STATUS_SUCCESS);
+}
diff --git a/src/tty/ntapi_tty_join_session.c b/src/tty/ntapi_tty_join_session.c
new file mode 100644
index 0000000..e88b9cb
--- /dev/null
+++ b/src/tty/ntapi_tty_join_session.c
@@ -0,0 +1,53 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tty_join_session(
+ __out void ** hport,
+ __out nt_port_name * port_name,
+ __in nt_port_attr * port_attr,
+ __in nt_tty_session_type type)
+{
+ nt_status status;
+ ntapi_internals * __internals;
+
+ /* init */
+ __internals = __ntapi_internals();
+
+ if (type == NT_TTY_SESSION_PRIMARY) {
+ hport = hport ? hport : &__internals->hport_tty_session;
+ port_name = port_name ? port_name : __internals->subsystem;
+ }
+
+ /* port name */
+ __ntapi->tt_port_name_from_attributes(
+ port_name,
+ port_attr);
+
+ /* connect to subsystem */
+ if ((status = __ntapi->tty_connect(
+ hport,
+ (wchar16_t *)port_name,
+ NT_SECURITY_IMPERSONATION)))
+ return status;
+
+ /* finalize primary session */
+ if (type == NT_TTY_SESSION_PRIMARY) {
+ if (hport != &__internals->hport_tty_session)
+ __internals->hport_tty_session = *hport;
+
+ if (port_name != __internals->subsystem)
+ __ntapi->tt_memcpy_utf16(
+ __internals->subsystem->base_named_objects,
+ port_name->base_named_objects,
+ sizeof(*port_name));
+ };
+
+ return status;
+}
diff --git a/src/tty/ntapi_tty_query_information_server.c b/src/tty/ntapi_tty_query_information_server.c
new file mode 100644
index 0000000..7930413
--- /dev/null
+++ b/src/tty/ntapi_tty_query_information_server.c
@@ -0,0 +1,40 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_tty.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tty_query_information_server(
+ __in void * hport,
+ __in nt_tty_server_info * srvinfo)
+{
+ int32_t status;
+ nt_tty_server_msg msg;
+
+ hport = hport ? hport : __ntapi_internals()->hport_tty_session;
+
+ __ntapi->tt_aligned_block_memset(
+ &msg,0,sizeof(msg));
+
+ msg.header.msg_type = NT_LPC_NEW_MESSAGE;
+ msg.header.data_size = sizeof(msg.data);
+ msg.header.msg_size = sizeof(msg);
+ msg.data.ttyinfo.opcode = NT_TTY_QUERY_INFORMATION_SERVER;
+
+ if ((status = __ntapi->zw_request_wait_reply_port(hport,&msg,&msg)))
+ return status;
+ else if (msg.data.ttyinfo.status)
+ return msg.data.ttyinfo.status;
+
+ __ntapi->tt_aligned_block_memcpy(
+ (uintptr_t *)srvinfo,
+ (uintptr_t *)&(msg.data.srvinfo),
+ sizeof(*srvinfo));
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/tty/ntapi_tty_request_peer.c b/src/tty/ntapi_tty_request_peer.c
new file mode 100644
index 0000000..9f6550d
--- /dev/null
+++ b/src/tty/ntapi_tty_request_peer.c
@@ -0,0 +1,46 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_tty.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tty_request_peer(
+ __in void * hport,
+ __in int32_t opcode,
+ __in uint32_t flags,
+ __in const nt_guid * service,
+ __in nt_port_attr * peer)
+{
+ int32_t status;
+ nt_tty_peer_msg msg;
+
+ __ntapi->tt_aligned_block_memset(
+ &msg,0,sizeof(msg));
+
+ msg.header.msg_type = NT_LPC_NEW_MESSAGE;
+ msg.header.data_size = sizeof(msg.data);
+ msg.header.msg_size = sizeof(msg);
+ msg.data.ttyinfo.opcode = NT_TTY_REQUEST_PEER;
+
+ msg.data.peerinfo.opcode= opcode;
+ msg.data.peerinfo.flags = flags;
+
+ if (service) __ntapi->tt_guid_copy(
+ &msg.data.peerinfo.service,
+ service);
+
+ __ntapi->tt_aligned_block_memcpy(
+ (uintptr_t *)&msg.data.peerinfo.peer,
+ (uintptr_t *)peer,
+ sizeof(*peer));
+
+ if ((status = __ntapi->zw_request_wait_reply_port(hport,&msg,&msg)))
+ return status;
+
+ return msg.data.ttyinfo.status;
+}
diff --git a/src/tty/ntapi_tty_vms_query.c b/src/tty/ntapi_tty_vms_query.c
new file mode 100644
index 0000000..08e3212
--- /dev/null
+++ b/src/tty/ntapi_tty_vms_query.c
@@ -0,0 +1,40 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_tty.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tty_vms_query(
+ __in void * hport,
+ __in nt_tty_vms_info * vmsinfo)
+{
+ int32_t status;
+ nt_tty_vms_msg msg;
+
+ hport = hport ? hport : __ntapi_internals()->hport_tty_session;
+
+ __ntapi->tt_aligned_block_memset(
+ &msg,0,sizeof(msg));
+
+ msg.header.msg_type = NT_LPC_NEW_MESSAGE;
+ msg.header.data_size = sizeof(msg.data);
+ msg.header.msg_size = sizeof(msg);
+ msg.data.ttyinfo.opcode = NT_TTY_VMS_QUERY;
+
+ if ((status = __ntapi->zw_request_wait_reply_port(hport,&msg,&msg)))
+ return status;
+ else if (msg.data.ttyinfo.status)
+ return msg.data.ttyinfo.status;
+
+ __ntapi->tt_aligned_block_memcpy(
+ (uintptr_t *)vmsinfo,
+ (uintptr_t *)&(msg.data.vmsinfo),
+ sizeof(*vmsinfo));
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/tty/ntapi_tty_vms_request.c b/src/tty/ntapi_tty_vms_request.c
new file mode 100644
index 0000000..74dbf5b
--- /dev/null
+++ b/src/tty/ntapi_tty_vms_request.c
@@ -0,0 +1,46 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_tty.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+int32_t __stdcall __ntapi_tty_vms_request(
+ __in void * hport,
+ __in nt_tty_vms_info * vmsinfo)
+{
+ int32_t status;
+ nt_tty_vms_msg msg;
+
+ hport = hport ? hport : __ntapi_internals()->hport_tty_session;
+
+ __ntapi->tt_aligned_block_memset(
+ &msg,0,
+ sizeof(nt_port_message) + sizeof(nt_tty_msg_info));
+
+ msg.header.msg_type = NT_LPC_NEW_MESSAGE;
+ msg.header.data_size = sizeof(msg.data);
+ msg.header.msg_size = sizeof(msg);
+ msg.data.ttyinfo.opcode = NT_TTY_VMS_REQUEST;
+
+ __ntapi->tt_aligned_block_memcpy(
+ (uintptr_t *)&(msg.data.vmsinfo),
+ (uintptr_t *)vmsinfo,
+ sizeof(*vmsinfo));
+
+ if ((status = __ntapi->zw_request_wait_reply_port(hport,&msg,&msg)))
+ return status;
+ else if (msg.data.ttyinfo.status)
+ return msg.data.ttyinfo.status;
+
+ __ntapi->tt_aligned_block_memcpy(
+ (uintptr_t *)vmsinfo,
+ (uintptr_t *)&(msg.data.vmsinfo),
+ sizeof(*vmsinfo));
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/unicode/ntapi_uc_unicode_conversion_from_utf16.c b/src/unicode/ntapi_uc_unicode_conversion_from_utf16.c
new file mode 100644
index 0000000..102a24d
--- /dev/null
+++ b/src/unicode/ntapi_uc_unicode_conversion_from_utf16.c
@@ -0,0 +1,287 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_unicode.h>
+#include "ntapi_impl.h"
+
+
+static int32_t __fastcall __utf16_to_utf8_handler_1byte_or_null_termination(nt_utf16_callback_args * args)
+{
+ /*******************************************/
+ /* from: 00000000 0xxxxxxx (little endian) */
+ /* to: 0xxxxxxx (utf-8) */
+ /*******************************************/
+
+ uint8_t * dst;
+
+ if (args->dst >= args->dst_cap)
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ dst = (uint8_t *)args->dst;
+ *dst = *(uint8_t *)(args->src);
+
+ /* advance source and destination buffer */
+ args->src++;
+ args->dst = (void *)((uintptr_t)(args->dst) + 1);
+
+ /* bytes_written */
+ args->bytes_written++;
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+static int32_t __fastcall __utf16_to_utf8_handler_2bytes(nt_utf16_callback_args * args)
+{
+ /*******************************************/
+ /* from: 00000yyy yyxxxxxx (little endian) */
+ /* to: 110yyyyy 10xxxxxx (utf-8) */
+ /*******************************************/
+
+ const wchar16_t * src;
+ uint8_t * dst;
+
+ wchar16_t wx;
+ wchar16_t wy;
+
+ if ((uintptr_t)(args->dst) + 1 >= (uintptr_t)(args->dst_cap))
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ src = args->src;
+ dst = (uint8_t *)args->dst;
+
+ wy = *src;
+ wy >>= 6;
+
+ wx = *src;
+ wx <<= 10;
+ wx >>= 10;
+
+ /* write the y part */
+ *dst = (char)(0xC0 | wy);
+ dst++;
+
+ /* write the x part */
+ *dst = (char)(0x80 | wx);
+
+ /* advance source and destination buffer */
+ args->src++;
+ args->dst = (void *)((uintptr_t)(args->dst) + 2);
+
+ /* bytes_written */
+ args->bytes_written += 2;
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+static int32_t __fastcall __utf16_to_utf8_handler_3bytes(nt_utf16_callback_args * args)
+{
+ /********************************************/
+ /* from: zzzzyyyy yyxxxxxx (little endian) */
+ /* to: 1110zzzz 10yyyyyy 10xxxxxx (utf-8) */
+ /********************************************/
+
+ const wchar16_t * src;
+ uint8_t * dst;
+
+ wchar16_t wx;
+ wchar16_t wy;
+ wchar16_t wz;
+
+ if ((uintptr_t)(args->dst) + 2 >= (uintptr_t)(args->dst_cap))
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ src = args->src;
+ dst = (uint8_t *)args->dst;
+
+ wz = *src;
+ wz >>= 12;
+
+ wy = *src;
+ wy <<= 4;
+ wy >>= 10;
+
+ wx = *src;
+ wx <<= 10;
+ wx >>= 10;
+
+ /* write the z part */
+ *dst = (char)(0xE0 | wz);
+ dst++;
+
+ /* write the y part */
+ *dst = (char)(0x80 | wy);
+ dst++;
+
+ /* write the x part */
+ *dst = (char)(0x80 | wx);
+
+ /* advance source and destination buffer */
+ args->src++;
+ args->dst = (void *)((uintptr_t)(args->dst) + 3);
+
+ /* bytes_written */
+ args->bytes_written += 3;
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+static int32_t __fastcall __utf16_to_utf8_handler_4bytes(nt_utf16_callback_args * args)
+{
+ /****************************************************************/
+ /* from: 110110ww wwzzzzyy 110111yy yyxxxxxx (little endian) */
+ /* to: 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx (utf-8) */
+ /****************************************************************/
+
+ const wchar16_t * src;
+ uint8_t * dst;
+
+ wchar16_t wx;
+ wchar16_t wz;
+
+ wchar16_t wy_low;
+ wchar16_t wy_high;
+ wchar16_t ww;
+ wchar16_t uuuuu;
+ wchar16_t u_low;
+ wchar16_t u_high;
+
+ if ((uintptr_t)(args->dst) + 3 >= (uintptr_t)(args->dst_cap))
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ src = args->src;
+ dst = (uint8_t *)args->dst;
+
+ /* low two bytes */
+ wx = *src;
+ wx <<= 10;
+ wx >>= 10;
+
+ wy_low = *src;
+ wy_low <<= 6;
+ wy_low >>= 12;
+
+ /* (surrogate pair) */
+ src++;
+
+ /* high two bytes */
+ wy_high = *src;
+ wy_high <<= 14;
+ wy_high >>= 10;
+
+ wz = *src;
+ wz <<= 10;
+ wz >>= 12;
+ wz <<= 2;
+
+ ww = *src;
+ ww <<= 6;
+ ww >>= 12;
+
+ uuuuu = ww + 1;
+ u_high = uuuuu >> 2;
+ u_low = ((uuuuu << 14) >> 10);
+
+ /* 1st byte: 11110uuu */
+ *dst = (char)(0xF0 | u_high);
+ dst++;
+
+ /* 2nd byte: 10uuzzzz */
+ *dst = (char)(0x80 | u_low | wz);
+ dst++;
+
+ /* 3rd byte: 10yyyyyy */
+ *dst = (char)(0x80 | wy_low | wy_high);
+ dst++;
+
+ /* 4th byte: 10xxxxxx */
+ *dst = (char)(0x80 | wx);
+
+ /* advance source and destination buffer */
+ args->src += 2;
+ args->dst = (void *)((uintptr_t)(args->dst) + 4);
+
+ /* bytes_written */
+ args->bytes_written += 4;
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+static int32_t __fastcall __update_stream_leftover_info_utf16(
+ __in_out nt_unicode_conversion_params_utf16_to_utf8 * params)
+{
+ int32_t status;
+ ptrdiff_t offset;
+ wchar16_t * wlead;
+
+ offset = (uintptr_t)params->src + (uintptr_t)params->src_size_in_bytes - (uintptr_t)params->addr_failed;
+ wlead = (wchar16_t *)params->addr_failed;
+
+
+ if ((offset == 2) && (*wlead >= 0xD800) && (*wlead < 0xDC00)) {
+ /* possibly the lead of a surrogate pair lead */
+ params->leftover_count = 2;
+ params->leftover_bytes = *wlead;
+ params->leftover_bytes <<= 16;
+ status = NT_STATUS_SUCCESS;
+ } else {
+ params->leftover_count = 0;
+ params->leftover_bytes = 0;
+ status = NT_STATUS_ILLEGAL_CHARACTER;
+ }
+
+ return status;
+}
+
+
+int32_t __stdcall __ntapi_uc_convert_unicode_stream_utf16_to_utf8(
+ __in_out nt_unicode_conversion_params_utf16_to_utf8 * params)
+{
+ int32_t status;
+ nt_utf16_callback_args args;
+ ntapi_uc_utf16_callback_fn * callback_fn[5];
+
+ callback_fn[0] = (ntapi_uc_utf16_callback_fn *)__utf16_to_utf8_handler_1byte_or_null_termination;
+ callback_fn[1] = (ntapi_uc_utf16_callback_fn *)__utf16_to_utf8_handler_1byte_or_null_termination;
+ callback_fn[2] = (ntapi_uc_utf16_callback_fn *)__utf16_to_utf8_handler_2bytes;
+ callback_fn[3] = (ntapi_uc_utf16_callback_fn *)__utf16_to_utf8_handler_3bytes;
+ callback_fn[4] = (ntapi_uc_utf16_callback_fn *)__utf16_to_utf8_handler_4bytes;
+
+ args.src = params->src;
+ args.dst = params->dst;
+ args.dst_cap = (void *)((uintptr_t)(params->dst) + (params->dst_size_in_bytes));
+ args.bytes_written = params->bytes_written;
+
+ status = __ntapi_uc_validate_unicode_stream_utf16(
+ params->src,
+ params->src_size_in_bytes,
+ ¶ms->code_points,
+ ¶ms->addr_failed,
+ callback_fn,
+ &args);
+
+ params->bytes_written = args.bytes_written;
+
+ if (status)
+ status = __update_stream_leftover_info_utf16(params);
+
+ /* the following bit shift will be optimized out on 32-bit architectures */
+ params->leftover_bytes <<= (8 * (sizeof(uintptr_t) - sizeof(uint32_t)));
+
+ return status;
+}
+
+
+int32_t __stdcall __ntapi_uc_convert_unicode_stream_utf16_to_utf32(
+ __in_out nt_unicode_conversion_params_utf16_to_utf32 * params)
+{
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/unicode/ntapi_uc_unicode_conversion_from_utf8.c b/src/unicode/ntapi_uc_unicode_conversion_from_utf8.c
new file mode 100644
index 0000000..02976ea
--- /dev/null
+++ b/src/unicode/ntapi_uc_unicode_conversion_from_utf8.c
@@ -0,0 +1,288 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_unicode.h>
+#include "ntapi_impl.h"
+
+
+typedef struct ___two_bytes {
+ unsigned char low;
+ unsigned char high;
+} __two_bytes;
+
+
+typedef struct ___three_bytes {
+ unsigned char low;
+ unsigned char middle;
+ unsigned char high;
+} __three_bytes;
+
+
+static int32_t __fastcall __utf8_to_utf16_handler_1byte_or_null_termination(nt_utf8_callback_args * args)
+{
+ /***************************/
+ /* from: 0xxxxxxx */
+ /* to: 00000000 0xxxxxxx */
+ /***************************/
+
+ wchar16_t * dst;
+
+ if (args->dst >= args->dst_cap)
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ dst = (wchar16_t *)args->dst;
+ *dst = *(args->src);
+
+ /* advance source and destination buffer */
+ args->src++;
+ args->dst = (void *)((uintptr_t)(args->dst) + sizeof(wchar16_t));
+
+ /* bytes_written */
+ args->bytes_written += sizeof(wchar16_t);
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+static int32_t __fastcall __utf8_to_utf16_handler_2bytes(nt_utf8_callback_args * args)
+{
+ /***************************/
+ /* from: 110yyyyy 10xxxxxx */
+ /* to: 00000yyy yyxxxxxx */
+ /***************************/
+
+ __two_bytes * src; /* big endian */
+ wchar16_t * dst;
+
+ if (args->dst >= args->dst_cap)
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ src = (__two_bytes *)args->src;
+ dst = (wchar16_t *)args->dst;
+
+ /* yyyyy */
+ *dst = (src->low ^ 0xC0);
+ *dst <<= 6;
+
+ /* xxxxxx */
+ *dst |= (src->high ^ 0x80);
+
+ /* advance source and destination buffer */
+ args->src += 2;
+ args->dst = (void *)((uintptr_t)(args->dst) + sizeof(wchar16_t));
+
+ /* bytes_written */
+ args->bytes_written += sizeof(wchar16_t);
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+static int32_t __fastcall __utf8_to_utf16_handler_3bytes(nt_utf8_callback_args * args)
+{
+ /************************************/
+ /* from: 1110zzzz 10yyyyyy 10xxxxxx */
+ /* to: zzzzyyyy yyxxxxxx */
+ /************************************/
+
+ __three_bytes * src; /* big endian */
+ wchar16_t * dst;
+ wchar16_t yyyyy;
+
+ if (args->dst >= args->dst_cap)
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ src = (__three_bytes *)args->src;
+ dst = (wchar16_t *)args->dst;
+
+ /* zzzz */
+ *dst = (src->low ^ 0xE0);
+ *dst <<= 12;
+
+ /* yyyyy */
+ yyyyy = (src->middle ^ 0x80);
+ yyyyy <<= 6;
+ *dst |= yyyyy;
+
+ /* xxxxxx */
+ *dst |= (src->high ^ 0x80);
+
+ /* advance source and destination buffer */
+ args->src += 3;
+ args->dst = (void *)((uintptr_t)(args->dst) + sizeof(wchar16_t));
+
+ /* bytes_written */
+ args->bytes_written += sizeof(wchar16_t);
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+static int32_t __fastcall __utf8_to_utf16_handler_4bytes(nt_utf8_callback_args * args)
+{
+ /*************************************************/
+ /* from: 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx */
+ /* to: 110110ww wwzzzzyy 110111yy yyxxxxxx */
+ /*************************************************/
+
+ __two_bytes * src_low; /* big endian */
+ __two_bytes * src_high; /* big endian */
+ wchar16_t * dst_lead;
+ wchar16_t * dst_trail;
+
+ wchar16_t u;
+ unsigned char ulow;
+ unsigned char uhigh;
+ unsigned char yyyy;
+
+ dst_lead = dst_trail = (wchar16_t *)args->dst;
+ dst_trail++;
+
+ if ((uintptr_t)dst_trail >= (uintptr_t)args->dst_cap)
+ return NT_STATUS_BUFFER_TOO_SMALL;
+
+ src_low = src_high = (__two_bytes *)args->src;
+ src_high++;
+
+ /* u */
+ ulow = src_low->low ^ 0xF0;
+ uhigh = src_low->high ^ 0x80;
+
+ ulow <<= 2;
+ uhigh >>= 4;
+
+ u = ulow | uhigh;
+
+ /* 110110ww wwzzzzyy */
+ *dst_lead = 0xD800;
+ *dst_lead |= ((u-1) << 6);
+ *dst_lead |= ((src_low->high ^ 0x80) << 2);
+ *dst_lead |= ((src_high->low ^ 0x80) >> 4);
+
+ /* 110111yy yyxxxxxx */
+ yyyy = (src_high->low << 4);
+ *dst_trail = yyyy;
+ *dst_trail <<= 2;
+ *dst_trail |= (src_high->high ^ 0x80);
+ *dst_trail |= 0xDC00;
+
+ /* advance source and destination buffer */
+ args->src += 4;
+ args->dst = (void *)((uintptr_t)(args->dst) + (2 * sizeof(wchar16_t)));
+
+ /* bytes_written */
+ args->bytes_written += 2 * sizeof(wchar16_t);
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+static int32_t __fastcall __update_stream_leftover_info_utf8(
+ __in_out nt_unicode_conversion_params_utf8_to_utf16 * params)
+{
+ int32_t status;
+ ptrdiff_t offset;
+ unsigned char * utf8;
+
+ offset = (uintptr_t)params->src + (uintptr_t)params->src_size_in_bytes - (uintptr_t)params->addr_failed;
+ utf8 = (unsigned char *)params->addr_failed;
+
+ /* default status */
+ status = NT_STATUS_ILLEGAL_CHARACTER;
+
+ if (offset == 1) {
+ if ((utf8[0] >= 0xC2) && (utf8[0] <= 0xF4)) {
+ /* one leftover byte */
+ params->leftover_count = 1;
+ params->leftover_bytes = utf8[0];
+ params->leftover_bytes <<= 24;
+ status = NT_STATUS_SUCCESS;
+ }
+ } else if (offset == 2) {
+ if /* ------- */ (((utf8[0] == 0xE0) && (utf8[1] >= 0xA0) && (utf8[1] <= 0xBF))
+ || ((utf8[0] >= 0xE1) && (utf8[0] <= 0xEC) && (utf8[1] >= 0x80) && (utf8[1] <= 0xBF))
+ || ((utf8[0] == 0xED) && (utf8[1] >= 0x80) && (utf8[1] <= 0x9F))
+ || ((utf8[0] >= 0xEE) && (utf8[0] <= 0xEF) && (utf8[1] >= 0x80) && (utf8[1] <= 0xBF))
+ || ((utf8[0] == 0xF0) && (utf8[1] >= 0x90) && (utf8[1] <= 0xBF))
+ || ((utf8[0] >= 0xF1) && (utf8[0] <= 0xF3) && (utf8[1] >= 0x80) && (utf8[1] <= 0xBF))
+ || ((utf8[0] == 0xF4) && (utf8[1] >= 0x80) && (utf8[1] <= 0x8F))) {
+ /* two leftover bytes */
+ params->leftover_count = 2;
+ params->leftover_bytes = utf8[0];
+ params->leftover_bytes <<= 8;
+ params->leftover_bytes += utf8[1];
+ params->leftover_bytes <<= 16;
+ status = NT_STATUS_SUCCESS;
+ }
+ } else if (offset == 3) {
+ if /* ------- */ (((utf8[0] == 0xF0) && (utf8[1] >= 0x90) && (utf8[1] <= 0xBF))
+ || ((utf8[0] >= 0xF1) && (utf8[0] <= 0xF3) && (utf8[1] >= 0x80) && (utf8[1] <= 0xBF))
+ || ((utf8[0] == 0xF4) && (utf8[1] >= 0x80) && (utf8[1] <= 0x8F))) {
+ /* three leftover bytes */
+ params->leftover_count = 3;
+ params->leftover_bytes = utf8[0];
+ params->leftover_bytes <<= 8;
+ params->leftover_bytes += utf8[1];
+ params->leftover_bytes <<= 8;
+ params->leftover_bytes += utf8[2];
+ params->leftover_bytes <<= 8;
+ status = NT_STATUS_SUCCESS;
+ }
+ }
+
+ if (status != NT_STATUS_SUCCESS) {
+ params->leftover_count = 0;
+ params->leftover_bytes = 0;
+ }
+
+ return status;
+}
+
+int32_t __stdcall __ntapi_uc_convert_unicode_stream_utf8_to_utf16(
+ __in_out nt_unicode_conversion_params_utf8_to_utf16 * params)
+{
+ int32_t status;
+ nt_utf8_callback_args args;
+ ntapi_uc_utf8_callback_fn * callback_fn[5];
+
+ callback_fn[0] = (ntapi_uc_utf8_callback_fn *)__utf8_to_utf16_handler_1byte_or_null_termination;
+ callback_fn[1] = (ntapi_uc_utf8_callback_fn *)__utf8_to_utf16_handler_1byte_or_null_termination;
+ callback_fn[2] = (ntapi_uc_utf8_callback_fn *)__utf8_to_utf16_handler_2bytes;
+ callback_fn[3] = (ntapi_uc_utf8_callback_fn *)__utf8_to_utf16_handler_3bytes;
+ callback_fn[4] = (ntapi_uc_utf8_callback_fn *)__utf8_to_utf16_handler_4bytes;
+
+ args.src = params->src;
+ args.dst = params->dst;
+ args.dst_cap = (void *)((uintptr_t)(params->dst) + (params->dst_size_in_bytes));
+ args.bytes_written = params->bytes_written;
+
+ status = __ntapi_uc_validate_unicode_stream_utf8(
+ params->src,
+ params->src_size_in_bytes,
+ ¶ms->code_points,
+ ¶ms->addr_failed,
+ callback_fn,
+ &args);
+
+ params->bytes_written = args.bytes_written;
+
+ if (status != NT_STATUS_SUCCESS)
+ status = __update_stream_leftover_info_utf8(params);
+
+ /* (optimized out on 32-bit architectures) */
+ params->leftover_bytes <<= (8 * (sizeof(uintptr_t) - sizeof(uint32_t)));
+
+ return status;
+}
+
+
+int32_t __stdcall __ntapi_uc_convert_unicode_stream_utf8_to_utf32(
+ __in_out nt_unicode_conversion_params_utf8_to_utf32 * params)
+{
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/unicode/ntapi_uc_unicode_validation.c b/src/unicode/ntapi_uc_unicode_validation.c
new file mode 100644
index 0000000..4c6fcac
--- /dev/null
+++ b/src/unicode/ntapi_uc_unicode_validation.c
@@ -0,0 +1,329 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_unicode.h>
+
+/**
+ * unofficial bit distribution table for comprehension purposes only
+ *
+ * scalar nickname utf-16 utf-8[0] utf-8[1] utf-8[2] utf-8[3]
+ * ------ -------- -------- -------- -------- -------- --------
+ * 00000000 7x 00000000 0xxxxxxx
+ * 0xxxxxxx 0xxxxxxx
+ *
+ * 00000yyy 5y6x 00000yyy 110yyyyy 10xxxxxx
+ * yyxxxxxx yyxxxxxx
+ *
+ * zzzzyyyy 4z6y6x zzzzyyyy 1110zzzz 10yyyyyy 10xxxxxx
+ * yyxxxxxx yyxxxxxx
+ *
+ * 000uuuuu 5u4z6y6x 110110ww 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx
+ * zzzzyyyy wwzzzzyy
+ * yyxxxxxx 110111yy
+ * yyxxxxxx (where wwww = uuuuu - 1)
+ *
+ *
+ * validation of utf-8
+ *
+ * from to utf-8[0] utf-8[1] utf-8[2] utf-8[3]
+ * ------ ------ -------- -------- -------- --------
+ * 0x0000 0x007F 00..7F
+ * 0x0080 0x07FF C2..DF 80..BF
+ * 0x0800 0x0FFF E0 A0..BF 80..BF
+ * 0x1000 0xCFFF E1..EC 80..BF 80..BF
+ * 0xD000 0xD7FF ED 80..9F 80..BF
+ * 0xE000 0xFFFF EE..EF 80..BF 80..BF
+ * 0x10000 0x3FFFF F0 90..BF 80..BF 80..BF
+ * 0x40000 0xFFFFF F1..F3 80..BF 80..BF 80..BF
+ * 0x100000 0x10FFFF F4 80..8F 80..BF 80..BF
+ *
+**/
+
+
+#define __AVAILABLE_CODE_POINTS 0x110000
+
+int __stdcall __ntapi_uc_get_code_point_byte_count_utf8(uint32_t code_point)
+{
+ /* try clearing 7x bits */
+ if ((code_point >> 7) == 0)
+ return 1;
+
+ /* try clearing 5y + 6x bits */
+ else if ((code_point >> 11) == 0)
+ return 2;
+
+ /* try clearing 4z +6y + 6x bits */
+ else if ((code_point >> 16) == 0)
+ return 3;
+
+ /* try clearing 5u + 4z + 6y + 6x bits */
+ else if ((code_point >> 21) == 0)
+ return 4;
+
+ /* __AVAILABLE_CODE_POINTS exceeded */
+ else
+ return 0;
+}
+
+
+int __stdcall __ntapi_uc_get_code_point_byte_count_utf16(uint32_t code_point)
+{
+ /* try clearing 4z +6y + 6x bits */
+ if ((code_point >> 16) == 0)
+ return 2;
+
+ /* try clearing 5u + 4z + 6y + 6x bits */
+ else if ((code_point >> 21) == 0)
+ return 4;
+
+ /* __AVAILABLE_CODE_POINTS exceeded */
+ else
+ return 0;
+}
+
+
+/**
+ * following is a straight-forward implementation
+ * of unicode conversion and validation (see also:
+ * Table 3-7 of the Unicode Standard, version 6.2).
+ *
+ * the use of callbacks allows the validation
+ * functions to be the basis of our utf-8 conversion
+ * functions on the one hand, and the posix path arg
+ * normalization routine on the other.
+**/
+
+static int32_t __fastcall __default_callback_fn_utf8(nt_utf8_callback_args * args)
+{
+ args->src += args->byte_count;
+ return NT_STATUS_SUCCESS;
+}
+
+int32_t __stdcall __ntapi_uc_validate_unicode_stream_utf8(
+ __in const unsigned char * ch,
+ __in size_t size_in_bytes __optional,
+ __out size_t * code_points __optional,
+ __out void ** addr_failed __optional,
+ __in ntapi_uc_utf8_callback_fn ** callback_fn __optional,
+ __in nt_utf8_callback_args * callback_args __optional)
+{
+ const unsigned char * utf8;
+ unsigned char * ch_boundary;
+ unsigned char byte_count;
+ size_t _code_points;
+
+ ntapi_uc_utf8_callback_fn * _callback_fn[5];
+ nt_utf8_callback_args _callback_args;
+
+ if (!callback_fn) {
+ _callback_fn[0] = __default_callback_fn_utf8;
+ _callback_fn[1] = __default_callback_fn_utf8;
+ _callback_fn[2] = __default_callback_fn_utf8;
+ _callback_fn[3] = __default_callback_fn_utf8;
+ _callback_fn[4] = __default_callback_fn_utf8;
+ callback_fn = (ntapi_uc_utf8_callback_fn **)&_callback_fn;
+ }
+
+ if (!callback_args) {
+ callback_args = &_callback_args;
+ callback_args->src = (unsigned char *)0;
+ }
+
+ if (callback_args->src)
+ ch = callback_args->src;
+ else
+ callback_args->src = ch;
+
+ if (size_in_bytes)
+ ch_boundary = (unsigned char *)((uintptr_t)ch + size_in_bytes);
+ else
+ ch_boundary = (unsigned char *)(~0);
+
+ if (!code_points)
+ code_points = &_code_points;
+
+ while ((ch < ch_boundary) && (*ch)) {
+ utf8 = ch;
+ byte_count = 0;
+
+ /* try one byte */
+ if (utf8[0] <= 0x7F)
+ byte_count = 1;
+
+ /* try two bytes */
+ else if ((++ch < ch_boundary)
+ && (utf8[0] >= 0xC2) && (utf8[0] <= 0xDF)
+ && (utf8[1] >= 0x80) && (utf8[1] <= 0xBF))
+ byte_count = 2;
+
+ /* try three bytes */
+ else if ((++ch < ch_boundary)
+ && (utf8[0] == 0xE0)
+ && (utf8[1] >= 0xA0) && (utf8[1] <= 0xBF)
+ && (utf8[2] >= 0x80) && (utf8[2] <= 0xBF))
+ byte_count = 3;
+
+ else if (
+ (utf8[0] >= 0xE1) && (utf8[0] <= 0xEC)
+ && (utf8[1] >= 0x80) && (utf8[1] <= 0xBF)
+ && (utf8[2] >= 0x80) && (utf8[2] <= 0xBF))
+ byte_count = 3;
+
+ else if (
+ (utf8[0] == 0xED)
+ && (utf8[1] >= 0x80) && (utf8[1] <= 0x9F)
+ && (utf8[2] >= 0x80) && (utf8[2] <= 0xBF))
+ byte_count = 3;
+
+ else if (
+ (utf8[0] >= 0xEE) && (utf8[0] <= 0xEF)
+ && (utf8[1] >= 0x80) && (utf8[1] <= 0xBF)
+ && (utf8[2] >= 0x80) && (utf8[2] <= 0xBF))
+ byte_count = 3;
+
+ /* try four bytes */
+ else if ((++ch < ch_boundary)
+ && (utf8[0] == 0xF0)
+ && (utf8[1] >= 0x90) && (utf8[1] <= 0xBF)
+ && (utf8[2] >= 0x80) && (utf8[2] <= 0xBF)
+ && (utf8[3] >= 0x80) && (utf8[3] <= 0xBF))
+ byte_count = 4;
+
+ else if (
+ (utf8[0] >= 0xF1) && (utf8[0] <= 0xF3)
+ && (utf8[1] >= 0x80) && (utf8[1] <= 0xBF)
+ && (utf8[2] >= 0x80) && (utf8[2] <= 0xBF)
+ && (utf8[3] >= 0x80) && (utf8[3] <= 0xBF))
+ byte_count = 4;
+
+ else if (
+ (utf8[0] == 0xF4)
+ && (utf8[1] >= 0x80) && (utf8[1] <= 0x8F)
+ && (utf8[2] >= 0x80) && (utf8[2] <= 0xBF)
+ && (utf8[3] >= 0x80) && (utf8[3] <= 0xBF))
+ byte_count = 4;
+
+ if (byte_count) {
+ (*code_points)++;
+ callback_args->byte_count = byte_count;
+ callback_fn[byte_count](callback_args);
+ } else {
+ if (addr_failed)
+ *addr_failed = (void *)utf8;
+ return NT_STATUS_ILLEGAL_CHARACTER;
+ }
+
+ /* advance, transcode if needed */
+ ch = callback_args->src;
+ }
+
+ if ((ch < ch_boundary) && (*ch == 0))
+ callback_fn[0](callback_args);
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+static int32_t __fastcall __default_callback_fn_utf16(nt_utf16_callback_args * args)
+{
+ if (args->byte_count == 4)
+ args->src += 2;
+ else
+ args->src++;
+
+ return NT_STATUS_SUCCESS;
+}
+
+
+int32_t __stdcall __ntapi_uc_validate_unicode_stream_utf16(
+ __in const wchar16_t * wch,
+ __in size_t size_in_bytes __optional,
+ __out size_t * code_points __optional,
+ __out void ** addr_failed __optional,
+ __in ntapi_uc_utf16_callback_fn ** callback_fn __optional,
+ __in nt_utf16_callback_args * callback_args __optional)
+{
+ const wchar16_t * wch_trail;
+ wchar16_t * wch_boundary;
+ unsigned char byte_count;
+ size_t _code_points;
+
+ ntapi_uc_utf16_callback_fn * _callback_fn[5];
+ nt_utf16_callback_args _callback_args;
+
+ if (!callback_fn) {
+ _callback_fn[0] = __default_callback_fn_utf16;
+ _callback_fn[1] = __default_callback_fn_utf16;
+ _callback_fn[2] = __default_callback_fn_utf16;
+ _callback_fn[3] = __default_callback_fn_utf16;
+ _callback_fn[4] = __default_callback_fn_utf16;
+ callback_fn = (ntapi_uc_utf16_callback_fn **)&_callback_fn;
+ }
+
+ if (!callback_args) {
+ callback_args = &_callback_args;
+ callback_args->src = (wchar16_t *)0;
+ }
+
+ if (callback_args->src)
+ wch = callback_args->src;
+ else
+ callback_args->src = wch;
+
+ if (size_in_bytes)
+ wch_boundary = (wchar16_t *)((uintptr_t)wch + size_in_bytes);
+ else
+ wch_boundary = (wchar16_t *)(~0);
+
+ if (!code_points)
+ code_points = &_code_points;
+
+ while ((wch < wch_boundary) && (*wch)) {
+ byte_count = 0;
+
+ /* try one byte */
+ if (*wch <= 0x7F)
+ byte_count = 1;
+
+ /* try two bytes */
+ else if (*wch <= 0x7FF)
+ byte_count = 2;
+
+ /* try three bytes */
+ else if ((*wch < 0xD800) || (*wch >= 0xE000))
+ byte_count = 3;
+
+ /* try four bytes */
+ else if ((*wch >= 0xD800) && (*wch < 0xDC00)) {
+ wch_trail = wch + 1;
+
+ if ((wch_trail < wch_boundary)
+ && (*wch_trail >= 0xDC00)
+ && (*wch_trail < 0xE000))
+ byte_count = 4;
+ }
+
+ if (byte_count) {
+ (*code_points)++;
+ callback_args->byte_count = byte_count;
+ callback_fn[byte_count](callback_args);
+ } else {
+ if (addr_failed)
+ *addr_failed = (void *)wch;
+ return NT_STATUS_ILLEGAL_CHARACTER;
+ }
+
+ /* advance, transcode as needed */
+ wch = callback_args->src;
+ }
+
+ if ((wch < wch_boundary) && (*wch == 0))
+ callback_fn[0](callback_args);
+
+ return NT_STATUS_SUCCESS;
+}
diff --git a/src/vfd/ntapi_vfd_helper.c b/src/vfd/ntapi_vfd_helper.c
new file mode 100644
index 0000000..054a388
--- /dev/null
+++ b/src/vfd/ntapi_vfd_helper.c
@@ -0,0 +1,34 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_status.h>
+#include <ntapi/nt_object.h>
+#include <ntapi/nt_vfd.h>
+#include "ntapi_impl.h"
+
+void __stdcall __ntapi_vfd_dev_name_init(
+ __out nt_vfd_dev_name * devname,
+ __in const nt_guid * guid)
+{
+ uint32_t * prefix = (uint32_t *)devname->prefix;
+
+ /* compiler-independent */
+ prefix[0] = 0x44005C;
+ prefix[1] = 0x760065;
+ prefix[2] = 0x630069;
+ prefix[3] = 0x5C0065;
+
+ __ntapi->tt_guid_to_utf16_string(
+ guid,
+ &devname->guid);
+
+ devname->name.strlen = sizeof(devname->prefix) + sizeof(devname->guid);
+ devname->name.maxlen = 0;
+ devname->name.buffer = (uint16_t *)&devname->prefix;
+
+ return;
+}
diff --git a/src/vmount/ntapi_vms_cache.c b/src/vmount/ntapi_vms_cache.c
new file mode 100644
index 0000000..97fe32f
--- /dev/null
+++ b/src/vmount/ntapi_vms_cache.c
@@ -0,0 +1,209 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_vmount.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+
+typedef struct nt_vms_cache_interface {
+ nt_vms_system * vms_sys;
+ struct dalist_ex cache;
+ size_t alloc_size;
+ uintptr_t buffer[1];
+} nt_vms_cache_context;
+
+
+typedef struct _nt_vms_cache_record {
+ void * hfile;
+ uint32_t dev_name_hash;
+ nt_large_integer index_number;
+ intptr_t client_key;
+ intptr_t server_key;
+} nt_vms_cache_record;
+
+
+int32_t __stdcall __ntapi_vms_cache_free(
+ __in nt_vms_cache vms_cache)
+{
+ int32_t status;
+ void * region_addr;
+ size_t region_size;
+
+ /* validation */
+ if (!vms_cache)
+ return NT_STATUS_INVALID_PARAMETER;
+
+ /* free memory */
+ region_addr = vms_cache;
+ region_size = vms_cache->alloc_size;
+
+ status = __ntapi->zw_free_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ ®ion_addr,
+ ®ion_size,
+ NT_MEM_RELEASE);
+
+ return status;
+}
+
+/* vms optional cache functions */
+nt_vms_cache __stdcall __ntapi_vms_cache_alloc(
+ __in nt_vms_system * vms_sys,
+ __in uint32_t flags __reserved,
+ __in void * options __reserved,
+ __out int32_t * status __optional)
+{
+ int32_t _status;
+ void * buffer;
+ size_t buffer_size;
+ nt_vms_cache_context * vms_cache;
+
+ /* status */
+ if (!status) status = &_status;
+
+ /* validation */
+ if (!vms_sys) {
+ *status = NT_STATUS_INVALID_PARAMETER;
+ return (nt_vms_cache)0;
+ }
+
+ /* calculate size */
+ buffer_size = sizeof(nt_vms_cache_context);
+ buffer_size += vms_sys->vms_points_cap * (sizeof(nt_vms_cache_record) - sizeof(uintptr_t));
+
+ /* allocate buffer */
+ *status = __ntapi->zw_allocate_virtual_memory(
+ NT_CURRENT_PROCESS_HANDLE,
+ &buffer,
+ 0,
+ &buffer_size,
+ NT_MEM_COMMIT,
+ NT_PAGE_READWRITE);
+
+ if (*status) return (nt_vms_cache)0;
+
+ /* init vms cache */
+ vms_cache = (nt_vms_cache_context *)buffer;
+ vms_cache->vms_sys = vms_sys;
+ vms_cache->alloc_size = buffer_size;
+
+ /* init list */
+ *status = dalist_init_ex(
+ &vms_cache->cache,
+ sizeof(nt_vms_cache_record),
+ 0x1000,
+ __ntapi->zw_allocate_virtual_memory,
+ DALIST_MEMFN_NT_ALLOCATE_VIRTUAL_MEMORY);
+
+ if (*status != DALIST_OK) {
+ *status = NT_STATUS_UNSUCCESSFUL;
+ __ntapi_vms_cache_free(vms_cache);
+ return (nt_vms_cache)0;
+ }
+
+ /* set list buffer */
+ buffer_size -= (size_t)&(((nt_vms_cache_context *)0)->buffer);
+
+ *status = dalist_deposit_memory_block(
+ &vms_cache->cache,
+ &vms_cache->buffer,
+ buffer_size);
+
+ return vms_cache;
+}
+
+
+int32_t __stdcall __ntapi_vms_cache_record_append(
+ __in nt_vms_cache cache,
+ __in void * hfile,
+ __in uint32_t dev_name_hash,
+ __in nt_large_integer index_number,
+ __in intptr_t client_key,
+ __in intptr_t server_key)
+{
+ int32_t status;
+ struct dalist_node_ex * node;
+ nt_vms_cache_record * cache_record;
+
+ status = dalist_get_node_by_key(
+ &cache->cache,
+ &node,
+ (uintptr_t)hfile,
+ DALIST_NODE_TYPE_EXISTING,
+ (uintptr_t *)0);
+
+ if (status != DALIST_OK)
+ status = NT_STATUS_INTERNAL_ERROR;
+ else if (node)
+ status = NT_STATUS_OBJECTID_EXISTS;
+ else {
+ status = dalist_get_free_node(&cache->cache,(void **)&node);
+
+ if (status == DALIST_OK) {
+ cache_record = (nt_vms_cache_record *)&node->dblock;
+
+ __ntapi->tt_aligned_block_memset(
+ node,
+ 0,
+ (uintptr_t)&((struct dalist_node_ex *)0)->dblock + sizeof(*cache_record));
+
+ node->key = (uintptr_t)hfile;
+
+ cache_record->hfile = hfile;
+ cache_record->dev_name_hash = dev_name_hash;
+ cache_record->index_number.quad = index_number.quad;
+ cache_record->client_key = client_key;
+ cache_record->server_key = server_key;
+
+ status = dalist_insert_node_by_key(
+ &cache->cache,
+ node);
+
+ if (status != DALIST_OK)
+ dalist_deposit_free_node(
+ &cache->cache,
+ node);
+ }
+ }
+
+ return status;
+}
+
+
+int32_t __stdcall __ntapi_vms_cache_record_remove(
+ __in nt_vms_cache cache,
+ __in void * hfile,
+ __in uint32_t dev_name_hash,
+ __in nt_large_integer index_number)
+{
+ int32_t status;
+ struct dalist_node_ex * node;
+
+ status = dalist_get_node_by_key(
+ &cache->cache,
+ &node,
+ (uintptr_t)hfile,
+ DALIST_NODE_TYPE_EXISTING,
+ (uintptr_t *)0);
+
+ if (status != DALIST_OK)
+ status = NT_STATUS_INTERNAL_ERROR;
+ else if (node)
+ status = NT_STATUS_INVALID_PARAMETER;
+ else {
+ status = dalist_discard_node(
+ &cache->cache,
+ node);
+
+ if (status != DALIST_OK)
+ status = NT_STATUS_INTERNAL_ERROR;
+ }
+
+ return status;
+}
diff --git a/src/vmount/ntapi_vms_client_connect.c b/src/vmount/ntapi_vms_client_connect.c
new file mode 100644
index 0000000..364d4d1
--- /dev/null
+++ b/src/vmount/ntapi_vms_client_connect.c
@@ -0,0 +1,86 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_tty.h>
+#include <ntapi/nt_vmount.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+
+static void __vms_port_name_from_server_info(
+ __out nt_port_name * vms_port_name,
+ __in nt_tty_vms_info * vmsinfo)
+{
+ nt_port_attr port_attr;
+
+ port_attr.type = NT_PORT_TYPE_VMOUNT;
+ port_attr.subtype = NT_PORT_SUBTYPE_DEFAULT;
+
+ __ntapi->tt_aligned_block_memcpy(
+ (uintptr_t *)&port_attr.keys,
+ (uintptr_t *)&vmsinfo->vms_keys,
+ sizeof(nt_port_keys));
+
+ __ntapi->tt_port_guid_from_type(
+ &port_attr.guid,
+ port_attr.type,
+ port_attr.subtype);
+
+ __ntapi->tt_port_name_from_attributes(
+ vms_port_name,
+ &port_attr);
+}
+
+
+int32_t __stdcall __ntapi_vms_client_connect(
+ __out void ** hvms,
+ __in nt_tty_vms_info * vmsinfo)
+{
+ int32_t status;
+ nt_port_name vms_port_name;
+
+ nt_unicode_string name;
+ nt_sqos sqos;
+ nt_oa oa;
+
+ /* vmount daemon port name */
+ __vms_port_name_from_server_info(
+ &vms_port_name,
+ vmsinfo);
+
+ /* port name init */
+ name.buffer = (wchar16_t *)&vms_port_name;
+ name.maxlen = 0;
+ name.strlen = (uint16_t)(size_t)(&((nt_port_name *)0)->null_termination);
+
+ /* init security structure */
+ sqos.length = sizeof(sqos);
+ sqos.impersonation_level = NT_SECURITY_IMPERSONATION;
+ sqos.context_tracking_mode = NT_SECURITY_TRACKING_DYNAMIC;
+ sqos.effective_only = 1;
+
+ /* init the port's object attributes */
+ oa.len = sizeof(oa);
+ oa.root_dir = (void *)0;
+ oa.obj_name = &name;
+ oa.obj_attr = 0;
+ oa.sec_desc = (nt_security_descriptor *)0;
+ oa.sec_qos = &sqos;
+
+ status = __ntapi->zw_connect_port(
+ hvms,
+ &name,
+ &sqos,
+ (nt_port_section_write *)0,
+ (nt_port_section_read *)0,
+ (uint32_t *)0,
+ (void *)0,
+ (uint32_t *)0);
+
+ return status;
+}
diff --git a/src/vmount/ntapi_vms_client_disconnect.c b/src/vmount/ntapi_vms_client_disconnect.c
new file mode 100644
index 0000000..b7d528c
--- /dev/null
+++ b/src/vmount/ntapi_vms_client_disconnect.c
@@ -0,0 +1,37 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_vmount.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+
+int32_t __stdcall __ntapi_vms_client_disconnect(
+ __in void * hvms)
+{
+ nt_vms_daemon_msg msg;
+
+ if (!hvms) return NT_STATUS_INVALID_HANDLE;
+
+ /* msg */
+ __ntapi->tt_aligned_block_memset(&msg,0,sizeof(msg));
+
+ msg.header.msg_type = NT_LPC_NEW_MESSAGE;
+ msg.header.data_size = sizeof(msg.data);
+ msg.header.msg_size = sizeof(msg);
+ msg.data.msginfo.opcode = NT_VMS_CLIENT_DISCONNECT;
+
+ /* zw_request_wait_reply_port */
+ __ntapi->zw_request_wait_reply_port(
+ hvms,
+ &msg,
+ &msg);
+
+ /* close client handle */
+ return __ntapi->zw_close(hvms);
+}
diff --git a/src/vmount/ntapi_vms_helper.c b/src/vmount/ntapi_vms_helper.c
new file mode 100644
index 0000000..4134112
--- /dev/null
+++ b/src/vmount/ntapi_vms_helper.c
@@ -0,0 +1,118 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_vmount.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+
+nt_vms_node * __stdcall __ntapi_vms_get_end_component_first_node(
+ __in nt_vms_system * pvms_sys,
+ __in uint32_t end_component_hash)
+{
+ nt_vms_node * node;
+
+ /* verify non-empty list and valid input */
+ if (!pvms_sys->dev_name_head_node || !end_component_hash)
+ return (nt_vms_node *)0;
+
+ /* find first node by end component hash */
+ node = (nt_vms_node *)((uintptr_t)pvms_sys + pvms_sys->end_component_head_node);
+
+ while (node->next && (node->end_component_hash < end_component_hash))
+ node = (nt_vms_node *)((uintptr_t)pvms_sys + node->next);
+
+ if (node->end_component_hash == end_component_hash)
+ return node;
+ else
+ return (nt_vms_node *)0;
+}
+
+
+static nt_vms_node * __stdcall __ntapi_vms_get_node(
+ __in nt_vms_system * pvms_sys,
+ __in uint32_t end_component_hash,
+ __in uint32_t dev_name_hash,
+ __in nt_large_integer index_number)
+{
+ nt_vms_node * node;
+
+ /* verify non-empty list */
+ if (!pvms_sys->dev_name_head_node)
+ return (nt_vms_node *)0;
+
+ /* end_component_hash */
+ if (end_component_hash) {
+ node = (nt_vms_node *)((uintptr_t)pvms_sys + pvms_sys->end_component_head_node);
+
+ while (node->next && (node->end_component_hash < end_component_hash))
+ node = (nt_vms_node *)((uintptr_t)pvms_sys + node->next);
+
+ if (node->end_component_hash != end_component_hash)
+ return (nt_vms_node *)0;
+ } else
+ node = (nt_vms_node *)((uintptr_t)pvms_sys + pvms_sys->dev_name_head_node);
+
+ /* find device nodes */
+ while (node->next && (node->dev_name_hash < dev_name_hash))
+ node = (nt_vms_node *)((uintptr_t)pvms_sys + node->next);
+
+ if (node->dev_name_hash != dev_name_hash)
+ return (nt_vms_node *)0;
+
+ /* find mount-point nodes */
+ while (node->next && (node->index_number.quad < index_number.quad))
+ node = (nt_vms_node *)((uintptr_t)pvms_sys + node->next);
+
+ if (node->index_number.quad != index_number.quad)
+ return (nt_vms_node *)0;
+
+ return node;
+}
+
+
+nt_vms_node * __stdcall __ntapi_vms_get_node_by_dev_name(
+ __in nt_vms_system * pvms_sys,
+ __in uint32_t dev_name_hash,
+ __in nt_large_integer index_number)
+{
+ return __ntapi_vms_get_node(
+ pvms_sys,
+ 0,
+ dev_name_hash,
+ index_number);
+}
+
+
+nt_vms_node * __stdcall __ntapi_vms_get_node_by_end_component(
+ __in nt_vms_system * pvms_sys,
+ __in uint32_t end_component_hash,
+ __in uint32_t dev_name_hash,
+ __in nt_large_integer index_number)
+{
+ return __ntapi_vms_get_node(
+ pvms_sys,
+ end_component_hash,
+ dev_name_hash,
+ index_number);
+}
+
+
+nt_vms_point * __stdcall __ntapi_vms_get_top_of_stack_mount_point(
+ __in nt_vms_system * pvms_sys,
+ __in nt_vms_node * node)
+{
+ nt_vms_point * point;
+
+ point = (nt_vms_point *)((uintptr_t)pvms_sys + node->stack);
+
+ while (point->next)
+ point = (nt_vms_point *)((uintptr_t)pvms_sys + point->next);
+
+ return point;
+}
diff --git a/src/vmount/ntapi_vms_point_attach.c b/src/vmount/ntapi_vms_point_attach.c
new file mode 100644
index 0000000..a4c5c7e
--- /dev/null
+++ b/src/vmount/ntapi_vms_point_attach.c
@@ -0,0 +1,52 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_vmount.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+
+static int32_t __stdcall __ntapi_vms_point_attach_detach(
+ __in void * hvms,
+ __in nt_vms_point_info * point_info,
+ __in int32_t vms_opcode)
+{
+ int32_t status;
+ nt_vms_daemon_msg msg;
+
+ /* msg */
+ __ntapi->tt_aligned_block_memset(&msg,0,sizeof(msg));
+
+ msg.header.msg_type = NT_LPC_NEW_MESSAGE;
+ msg.header.data_size = sizeof(msg.data);
+ msg.header.msg_size = sizeof(msg);
+ msg.data.msginfo.opcode = vms_opcode;
+
+ /* copy point to msg */
+ __ntapi->tt_aligned_block_memcpy(
+ (uintptr_t *)&(msg.data.pointinfo),
+ (uintptr_t *)point_info,
+ sizeof(*point_info));
+
+ /* zw_request_wait_reply_port */
+ status = __ntapi->zw_request_wait_reply_port(hvms,&msg,&msg);
+
+ /* return vms status */
+ return status ? status : msg.data.msginfo.status;
+}
+
+
+int32_t __stdcall __ntapi_vms_point_attach(
+ __in void * hvms,
+ __in nt_vms_point_info * point_info)
+{
+ return __ntapi_vms_point_attach_detach(
+ hvms,
+ point_info,
+ NT_VMS_POINT_ATTACH);
+}
diff --git a/src/vmount/ntapi_vms_ref_count.c b/src/vmount/ntapi_vms_ref_count.c
new file mode 100644
index 0000000..3be149f
--- /dev/null
+++ b/src/vmount/ntapi_vms_ref_count.c
@@ -0,0 +1,96 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_vmount.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+
+static int32_t __stdcall __ntapi_vms_ref_count_inc_dec(
+ __in void * hvms,
+ __in nt_vms_ref_count_info * ref_cnt_info,
+ __in int32_t vms_opcode)
+{
+ int32_t status;
+ nt_vms_daemon_msg msg;
+
+ /* msg */
+ __ntapi->tt_aligned_block_memset(&msg,0,sizeof(msg));
+
+ msg.header.msg_type = NT_LPC_NEW_MESSAGE;
+ msg.header.data_size = sizeof(msg.data);
+ msg.header.msg_size = sizeof(msg);
+ msg.data.msginfo.opcode = vms_opcode;
+
+ /* copy ref count info to msg */
+ __ntapi->tt_aligned_block_memcpy(
+ (uintptr_t *)&(msg.data.refcntinfo),
+ (uintptr_t *)ref_cnt_info,
+ sizeof(*ref_cnt_info));
+
+ /* zw_request_wait_reply_port */
+ status = __ntapi->zw_request_wait_reply_port(
+ hvms,
+ &msg,
+ &msg);
+
+ if (status) return status;
+
+ /* return info */
+ __ntapi->tt_aligned_block_memcpy(
+ (uintptr_t *)ref_cnt_info,
+ (uintptr_t *)&(msg.data.refcntinfo),
+ sizeof(*ref_cnt_info));
+
+ /* return vms status */
+ return status ? status : msg.data.msginfo.status;
+}
+
+
+int32_t __stdcall __ntapi_vms_ref_count_inc(
+ __in void * hvms,
+ __in nt_vms_ref_count_info * ref_cnt_info)
+{
+ return __ntapi_vms_ref_count_inc_dec(
+ hvms,
+ ref_cnt_info,
+ NT_VMS_REF_COUNT_INC);
+}
+
+
+int32_t __stdcall __ntapi_vms_ref_count_dec(
+ __in void * hvms,
+ __in nt_vms_ref_count_info * ref_cnt_info)
+{
+ return __ntapi_vms_ref_count_inc_dec(
+ hvms,
+ ref_cnt_info,
+ NT_VMS_REF_COUNT_DEC);
+}
+
+
+int32_t __stdcall __ntapi_vms_point_detach(
+ __in void * hvms,
+ __in nt_vms_ref_count_info * ref_cnt_info)
+{
+ return __ntapi_vms_ref_count_inc_dec(
+ hvms,
+ ref_cnt_info,
+ NT_VMS_POINT_DETACH);
+}
+
+
+int32_t __stdcall __ntapi_vms_point_get_handles(
+ __in void * hvms,
+ __in nt_vms_ref_count_info * ref_cnt_info)
+{
+ return __ntapi_vms_ref_count_inc_dec(
+ hvms,
+ ref_cnt_info,
+ NT_VMS_POINT_GET_HANDLES);
+}
diff --git a/src/vmount/ntapi_vms_table_query.c b/src/vmount/ntapi_vms_table_query.c
new file mode 100644
index 0000000..847a58f
--- /dev/null
+++ b/src/vmount/ntapi_vms_table_query.c
@@ -0,0 +1,45 @@
+/********************************************************/
+/* ntapi: Native API core library */
+/* Copyright (C) 2013,2014,2015 Z. Gilboa */
+/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
+/********************************************************/
+
+#include <psxtypes/psxtypes.h>
+#include <ntapi/nt_port.h>
+#include <ntapi/nt_vmount.h>
+#include <ntapi/ntapi.h>
+#include "ntapi_impl.h"
+
+
+int32_t __stdcall __ntapi_vms_table_query(
+ __in void * hvms,
+ __in nt_vms_daemon_info * vms_info)
+{
+ int32_t status;
+ nt_vms_daemon_msg msg;
+
+ /* msg */
+ __ntapi->tt_aligned_block_memset(&msg,0,sizeof(msg));
+
+ msg.header.msg_type = NT_LPC_NEW_MESSAGE;
+ msg.header.data_size = sizeof(msg.data);
+ msg.header.msg_size = sizeof(msg);
+ msg.data.msginfo.opcode = NT_VMS_TABLE_QUERY;
+
+ /* zw_request_wait_reply_port */
+ status = __ntapi->zw_request_wait_reply_port(
+ hvms,
+ &msg,
+ &msg);
+
+ if (status) return status;
+
+ /* return info */
+ __ntapi->tt_aligned_block_memcpy(
+ (uintptr_t *)vms_info,
+ (uintptr_t *)&(msg.data.vmsinfo),
+ sizeof(*vms_info));
+
+ /* return vms status */
+ return status ? status : msg.data.msginfo.status;
+}