summaryrefslogtreecommitdiffhomepage
path: root/src/argv/ntapi_tt_argv_envp.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/argv/ntapi_tt_argv_envp.c')
-rw-r--r--src/argv/ntapi_tt_argv_envp.c717
1 files changed, 717 insertions, 0 deletions
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;
+}