Make get/putenv and erlexec understand Unicode

Putenv and getenv needs to convert to the proper environment
strings in Unicode depending on platform and user settings for filename
encoding. Also erlexec needs to pass environment strings in an appropriate
way for kernel to pick up. All environment strings on the command
line, as well as home directory, is now passed in UTF8 on windows
and in whatever encoding you have on Unix, kernel tries to convert all
parameters and environments from UTF8 before making strings.

3 files changed, 306 insertions, 278 deletions

diff --git a/erts/emulator/sys/win32/erl_win_sys.h b/erts/emulator/sys/win32/erl_win_sys.h
index 03298a6c54..1e7b555f42 100644
--- a/erts/emulator/sys/win32/erl_win_sys.h
+++ b/erts/emulator/sys/win32/erl_win_sys.h
@@ -171,8 +171,8 @@ extern clock_t sys_times(SysTimes *buffer);
 extern char *win_build_environment(char *);
 
 typedef struct {
-    char *environment_strings;
-    char *next_string;
+    WCHAR *environment_strings;
+    WCHAR *next_string;
 } GETENV_STATE;
 
 void erts_sys_env_init(void);
diff --git a/erts/emulator/sys/win32/sys.c b/erts/emulator/sys/win32/sys.c
index acbbfc2ce9..29e2749800 100755
--- a/erts/emulator/sys/win32/sys.c
+++ b/erts/emulator/sys/win32/sys.c
@@ -1204,9 +1204,7 @@ spawn_start(ErlDrvPort port_num, char* name, SysDriverOpts* opts)
      */
 
     DEBUGF(("Spawning \"%s\"\n", name));
-    envir = win_build_environment(envir); /* Still an ansi environment, could be
-					     converted to unicode for spawn_executable, but
-					     that is not done (yet) */ 
+    envir = win_build_environment(envir); /* Always a unicode environment */ 
     ok = create_child_process(name, 
 			    hChildStdin, 
 			    hChildStdout,
@@ -1485,7 +1483,8 @@ create_child_process
 			    NULL, 
 			    NULL, 
 			    TRUE, 
-			    createFlags | staticCreateFlags, 
+			    createFlags | staticCreateFlags | 
+			    CREATE_UNICODE_ENVIRONMENT, 
 			    env, 
 			    wd, 
 			    &siStartInfo, 
@@ -1613,7 +1612,8 @@ create_child_process
 			    NULL, 
 			    NULL, 
 			    TRUE, 
-			    createFlags | staticCreateFlags, 
+			    createFlags | staticCreateFlags | 
+			    CREATE_UNICODE_ENVIRONMENT, 
 			    env, 
 			    (WCHAR *) wd, 
 			    &siStartInfo, 
diff --git a/erts/emulator/sys/win32/sys_env.c b/erts/emulator/sys/win32/sys_env.c
index 064745d418..658a77c824 100644
--- a/erts/emulator/sys/win32/sys_env.c
+++ b/erts/emulator/sys/win32/sys_env.c
@@ -1,271 +1,299 @@
-/*
- * %CopyrightBegin%
- *
- * Copyright Ericsson AB 2002-2011. All Rights Reserved.
- *
- * The contents of this file are subject to the Erlang Public License,
- * Version 1.1, (the "License"); you may not use this file except in
- * compliance with the License. You should have received a copy of the
- * Erlang Public License along with this software. If not, it can be
- * retrieved online at http://www.erlang.org/.
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * %CopyrightEnd%
- */
-
-#ifdef HAVE_CONFIG_H
-#  include "config.h"
-#endif
-
-#include "sys.h"
-#include "erl_sys_driver.h"
-#include "erl_alloc.h"
-
-static char* merge_environment(char *current, char *add);
-static char* arg_to_env(char **arg);
-static char** env_to_arg(char *env);
-static char** find_arg(char **arg, char *str);
-static int compare(const void *a, const void *b);
-
-static erts_smp_rwmtx_t environ_rwmtx;
-
-void
-erts_sys_env_init(void)
-{
-    erts_smp_rwmtx_init(&environ_rwmtx, "environ");
-}
-
-int
-erts_sys_putenv(char *key_value, int sep_ix)
-{
-    int res;
-    char sep = key_value[sep_ix];
-    ASSERT(sep == '=');
-    key_value[sep_ix] = '\0';
-    erts_smp_rwmtx_rwlock(&environ_rwmtx);
-    res = (SetEnvironmentVariable((LPCTSTR) key_value,
-				  (LPCTSTR) &key_value[sep_ix+1]) ? 0 : 1);
-    erts_smp_rwmtx_rwunlock(&environ_rwmtx);
-    key_value[sep_ix] = sep;
-    return res;
-}
-
-int
-erts_sys_getenv__(char *key, char *value, size_t *size)
-{
-    size_t req_size = 0;
-    int res = 0;
-    DWORD new_size;
-
-    SetLastError(0);
-    new_size = GetEnvironmentVariable((LPCTSTR) key,
-				      (LPTSTR) value,
-				      (DWORD) *size);
-    res = !new_size && GetLastError() == ERROR_ENVVAR_NOT_FOUND ? -1 : 0;
-    if (res < 0)
-	return res;
-    res = new_size > *size ? 1 : 0;
-    *size = new_size;
-    return res;
-}
-
-int
-erts_sys_getenv(char *key, char *value, size_t *size)
-{
-    int res;
-    erts_smp_rwmtx_rlock(&environ_rwmtx);
-    res = erts_sys_getenv__(key, value, size);
-    erts_smp_rwmtx_runlock(&environ_rwmtx);
-    return res;
-}
-
-struct win32_getenv_state {
-    char *env;
-    char *next;
-};
-
-
-void init_getenv_state(GETENV_STATE *state)
-{
-    erts_smp_rwmtx_rlock(&environ_rwmtx);
-    state->environment_strings = (char *) GetEnvironmentStrings();
-    state->next_string = state->environment_strings;
-}
-
-char *getenv_string(GETENV_STATE *state)
-{
-    ERTS_SMP_LC_ASSERT(erts_smp_lc_rwmtx_is_rlocked(&environ_rwmtx));
-    if (state->next_string[0] == '\0')
-	return NULL;
-    else {
-	char *res = state->next_string;
-	state->next_string += sys_strlen(res) + 1;
-	return res;
-    }
-}
-
-void fini_getenv_state(GETENV_STATE *state)
-{
-    FreeEnvironmentStrings(state->environment_strings);
-    state->environment_strings = state->next_string = NULL;
-    erts_smp_rwmtx_runlock(&environ_rwmtx);
-}
-
-char*
-win_build_environment(char* new_env)
-{
-    if (new_env == NULL) {
-	return NULL;
-    } else {
-	char *tmp, *merged;
-	
-	erts_smp_rwmtx_rlock(&environ_rwmtx);
-	tmp = GetEnvironmentStrings();
-	merged = merge_environment(tmp, new_env);
-
-	FreeEnvironmentStrings(tmp);
-	erts_smp_rwmtx_runlock(&environ_rwmtx);
-	return merged;
-    }
-}
-
-static char*
-merge_environment(char *old, char *add)
-{
-    char **a_arg = env_to_arg(add);
-    char **c_arg = env_to_arg(old);
-    char *ret;
-    int i, j;
-    
-    for(i = 0; c_arg[i] != NULL; ++i)
-	;
-
-    for(j = 0; a_arg[j] != NULL; ++j)
-	;
-
-    c_arg = erts_realloc(ERTS_ALC_T_TMP,
-			 c_arg, (i+j+1) * sizeof(char *));
-
-    for(j = 0; a_arg[j] != NULL; ++j){
-	char **tmp;
-	char *current = a_arg[j];
-	char *eq_p = strchr(current,'=');
-	int unset = (eq_p!=NULL && eq_p[1]=='\0');
-
-	if ((tmp = find_arg(c_arg, current)) != NULL) {
-	    if (!unset) {
-		*tmp = current;
-	    } else {
-		*tmp = c_arg[--i];
-		c_arg[i] = NULL;
-	    }
-	} else if (!unset) {
-	    c_arg[i++] = current;
-	    c_arg[i] = NULL;
-	}
-    }
-    ret = arg_to_env(c_arg);
-    erts_free(ERTS_ALC_T_TMP, c_arg);
-    erts_free(ERTS_ALC_T_TMP, a_arg);
-    return ret;
-}
-
-static char**
-find_arg(char **arg, char *str)
-{
-    char *tmp;
-    int len;
-
-    if ((tmp = strchr(str, '=')) != NULL) {
-	tmp++;
-	len = tmp - str;
-	while (*arg != NULL){
-	    if (_strnicmp(*arg, str, len) == 0){
-		return arg;
-	    }
-	    ++arg;
-	}
-    }
-    return NULL;
-}
-
-static int
-compare(const void *a, const void *b)
-{
-    char *s1 = *((char **) a);
-    char *s2 = *((char **) b);
-    char *e1 = strchr(s1,'=');
-    char *e2 = strchr(s2,'=');
-    int ret;
-    int len;
-  
-    if(!e1)
-	e1 = s1 + strlen(s1);
-    if(!e2)
-	e2 = s2 + strlen(s2);
-  
-    if((e1 - s1) > (e2 - s2))
-	len = (e2 - s2);
-    else
-	len = (e1 - s1);
-  
-    ret = _strnicmp(s1,s2,len);
-    if (ret == 0)
-	return ((e1 - s1) - (e2 - s2));
-    else
-	return ret;
-}
-
-static char**
-env_to_arg(char *env)
-{
-    char **ret;
-    char *tmp;
-    int i;
-    int num_strings = 0;
-
-    for(tmp = env; *tmp != '\0'; tmp += strlen(tmp)+1) {
-	++num_strings;
-    }
-    ret = erts_alloc(ERTS_ALC_T_TMP, sizeof(char *) * (num_strings + 1));
-    i = 0;
-    for(tmp = env; *tmp != '\0'; tmp += strlen(tmp)+1){
-	ret[i++] = tmp;
-    }
-    ret[i] = NULL;
-    return ret;
-}
-
-static char*
-arg_to_env(char **arg)
-{
-    char *block;
-    char *ptr;
-    int i;
-    int totlen = 1;		/* extra '\0' */
-
-    for(i = 0; arg[i] != NULL; ++i) {
-	totlen += strlen(arg[i])+1;
-    }
-
-    /* sort the environment vector */
-    qsort(arg, i, sizeof(char *), &compare);
-
-    if (totlen == 1){
-	block = erts_alloc(ERTS_ALC_T_ENVIRONMENT, 2);
-	block[0] = block[1] = '\0'; 
-    } else {
-	block = erts_alloc(ERTS_ALC_T_ENVIRONMENT, totlen);
-	ptr = block;
-	for(i=0; arg[i] != NULL; ++i){
-	    strcpy(ptr, arg[i]);
-	    ptr += strlen(ptr)+1;
-	}
-	*ptr = '\0';
-    }
-    return block;
-}
+/*

+ * %CopyrightBegin%

+ *

+ * Copyright Ericsson AB 2002-2011. All Rights Reserved.

+ *

+ * The contents of this file are subject to the Erlang Public License,

+ * Version 1.1, (the "License"); you may not use this file except in

+ * compliance with the License. You should have received a copy of the

+ * Erlang Public License along with this software. If not, it can be

+ * retrieved online at http://www.erlang.org/.

+ *

+ * Software distributed under the License is distributed on an "AS IS"

+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See

+ * the License for the specific language governing rights and limitations

+ * under the License.

+ *

+ * %CopyrightEnd%

+ */

+

+#ifdef HAVE_CONFIG_H

+#  include "config.h"

+#endif

+

+#include "sys.h"

+#include "erl_sys_driver.h"

+#include "erl_alloc.h"

+

+static WCHAR *merge_environment(WCHAR *current, WCHAR *add);

+static WCHAR *arg_to_env(WCHAR **arg);

+static WCHAR **env_to_arg(WCHAR *env);

+static WCHAR **find_arg(WCHAR **arg, WCHAR *str);

+static int compare(const void *a, const void *b);

+

+static erts_smp_rwmtx_t environ_rwmtx;

+

+void

+erts_sys_env_init(void)

+{

+    erts_smp_rwmtx_init(&environ_rwmtx, "environ");

+}

+

+int

+erts_sys_putenv_raw(char *key, char *value)

+{

+    int res;

+    erts_smp_rwmtx_rwlock(&environ_rwmtx);

+    res = (SetEnvironmentVariable((LPCTSTR) key,

+				  (LPCTSTR) value) ? 0 : 1);

+    erts_smp_rwmtx_rwunlock(&environ_rwmtx);

+    return res;

+}

+

+int

+erts_sys_putenv(char *key, char *value)

+{

+    int res;

+    WCHAR *wkey = (WCHAR *) key;

+    WCHAR *wvalue = (WCHAR *) value;

+    erts_smp_rwmtx_rwlock(&environ_rwmtx);

+    res = (SetEnvironmentVariableW(wkey,

+				   wvalue) ? 0 : 1);

+    erts_smp_rwmtx_rwunlock(&environ_rwmtx);

+    return res;

+}

+

+int

+erts_sys_getenv(char *key, char *value, size_t *size)

+{

+    size_t req_size = 0;

+    int res = 0;

+    DWORD new_size;

+    WCHAR *wkey = (WCHAR *) key;

+    WCHAR *wvalue = (WCHAR *) value;

+    DWORD wsize = *size / (sizeof(WCHAR) / sizeof(char));

+

+    SetLastError(0);

+    erts_smp_rwmtx_rlock(&environ_rwmtx);

+    new_size = GetEnvironmentVariableW(wkey,

+				       wvalue,

+				      (DWORD) wsize);

+    res = !new_size && GetLastError() == ERROR_ENVVAR_NOT_FOUND ? -1 : 0;

+    erts_smp_rwmtx_runlock(&environ_rwmtx);

+    if (res < 0)

+	return res;

+    res = new_size > wsize ? 1 : 0;

+    *size = new_size * (sizeof(WCHAR) / sizeof(char));

+    return res;

+}

+int

+erts_sys_getenv__(char *key, char *value, size_t *size)

+{

+    size_t req_size = 0;

+    int res = 0;

+    DWORD new_size;

+

+    SetLastError(0);

+    new_size = GetEnvironmentVariable((LPCTSTR) key,

+				      (LPTSTR) value,

+				      (DWORD) *size);

+    res = !new_size && GetLastError() == ERROR_ENVVAR_NOT_FOUND ? -1 : 0;

+    if (res < 0)

+	return res;

+    res = new_size > *size ? 1 : 0;

+    *size = new_size;

+    return res;

+}

+

+int

+erts_sys_getenv_raw(char *key, char *value, size_t *size)

+{

+    int res;

+    erts_smp_rwmtx_rlock(&environ_rwmtx);

+    res = erts_sys_getenv__(key, value, size);

+    erts_smp_rwmtx_runlock(&environ_rwmtx);

+    return res;

+}

+

+void init_getenv_state(GETENV_STATE *state)

+{

+    erts_smp_rwmtx_rlock(&environ_rwmtx);

+    state->environment_strings = GetEnvironmentStringsW();

+    state->next_string = state->environment_strings;

+}

+

+char *getenv_string(GETENV_STATE *state)

+{

+    ERTS_SMP_LC_ASSERT(erts_smp_lc_rwmtx_is_rlocked(&environ_rwmtx));

+    if (state->next_string[0] == L'\0') {

+	return NULL;

+    } else {

+	WCHAR *res = state->next_string;

+	state->next_string += wcslen(res) + 1;

+	return (char *) res;

+    }

+}

+

+void fini_getenv_state(GETENV_STATE *state)

+{

+    FreeEnvironmentStringsW(state->environment_strings);

+    state->environment_strings = state->next_string = NULL;

+    erts_smp_rwmtx_runlock(&environ_rwmtx);

+}

+

+char*

+win_build_environment(char* new_env)

+{

+    if (new_env == NULL) {

+	return NULL;

+    } else {

+	WCHAR *tmp, *merged, *tmp_new;

+

+	tmp_new = (WCHAR *) new_env;

+	

+	erts_smp_rwmtx_rlock(&environ_rwmtx);

+	tmp = GetEnvironmentStringsW();

+	merged = merge_environment(tmp, tmp_new);

+

+	FreeEnvironmentStringsW(tmp);

+	erts_smp_rwmtx_runlock(&environ_rwmtx);

+	return (char *) merged;

+    }

+}

+

+static WCHAR *

+merge_environment(WCHAR *old, WCHAR *add)

+{

+    WCHAR **a_arg = env_to_arg(add);

+    WCHAR **c_arg = env_to_arg(old);

+    WCHAR *ret;

+    int i, j;

+    

+    for(i = 0; c_arg[i] != NULL; ++i)

+	;

+

+    for(j = 0; a_arg[j] != NULL; ++j)

+	;

+

+    c_arg = erts_realloc(ERTS_ALC_T_TMP,

+			 c_arg, (i+j+1) * sizeof(WCHAR *));

+

+    for(j = 0; a_arg[j] != NULL; ++j){

+	WCHAR **tmp;

+	WCHAR *current = a_arg[j];

+	WCHAR *eq_p = wcschr(current,L'=');

+	int unset = (eq_p!=NULL && eq_p[1]==L'\0');

+

+	if ((tmp = find_arg(c_arg, current)) != NULL) {

+	    if (!unset) {

+		*tmp = current;

+	    } else {

+		*tmp = c_arg[--i];

+		c_arg[i] = NULL;

+	    }

+	} else if (!unset) {

+	    c_arg[i++] = current;

+	    c_arg[i] = NULL;

+	}

+    }

+    ret = arg_to_env(c_arg);

+    erts_free(ERTS_ALC_T_TMP, c_arg);

+    erts_free(ERTS_ALC_T_TMP, a_arg);

+    return ret;

+}

+

+static WCHAR**

+find_arg(WCHAR **arg, WCHAR *str)

+{

+    WCHAR *tmp;

+    int len;

+

+    if ((tmp = wcschr(str, L'=')) != NULL) {

+	tmp++;

+	len = tmp - str;

+	while (*arg != NULL){

+	    if (_wcsnicmp(*arg, str, len) == 0){

+		return arg;

+	    }

+	    ++arg;

+	}

+    }

+    return NULL;

+}

+

+static int

+compare(const void *a, const void *b)

+{

+    WCHAR *s1 = *((WCHAR **) a);

+    WCHAR *s2 = *((WCHAR **) b);

+    WCHAR *e1 = wcschr(s1,L'=');

+    WCHAR *e2 = wcschr(s2,L'=');

+    int ret;

+    int len;

+  

+    if(!e1)

+	e1 = s1 + wcslen(s1);

+    if(!e2)

+	e2 = s2 + wcslen(s2);

+  

+    if((e1 - s1) > (e2 - s2))

+	len = (e2 - s2);

+    else

+	len = (e1 - s1);

+  

+    ret = _wcsnicmp(s1,s2,len);

+    if (ret == 0)

+	return ((e1 - s1) - (e2 - s2));

+    else

+	return ret;

+}

+

+static WCHAR**

+env_to_arg(WCHAR *env)

+{

+    WCHAR **ret;

+    WCHAR *tmp;

+    int i;

+    int num_strings = 0;

+

+    for(tmp = env; *tmp != '\0'; tmp += wcslen(tmp)+1) {

+	++num_strings;

+    }

+    ret = erts_alloc(ERTS_ALC_T_TMP, sizeof(WCHAR *) * (num_strings + 1));

+    i = 0;

+    for(tmp = env; *tmp != '\0'; tmp += wcslen(tmp)+1){

+	ret[i++] = tmp;

+    }

+    ret[i] = NULL;

+    return ret;

+}

+

+static WCHAR *

+arg_to_env(WCHAR **arg)

+{

+    WCHAR *block;

+    WCHAR *ptr;

+    int i;

+    int totlen = 1;		/* extra '\0' */

+

+    for(i = 0; arg[i] != NULL; ++i) {

+	totlen += wcslen(arg[i])+1;

+    }

+

+    /* sort the environment vector */

+    qsort(arg, i, sizeof(WCHAR *), &compare);

+

+    if (totlen == 1){

+	block = erts_alloc(ERTS_ALC_T_ENVIRONMENT, 2 * sizeof(WCHAR));

+	block[0] = block[1] = '\0'; 

+    } else {

+	block = erts_alloc(ERTS_ALC_T_ENVIRONMENT, totlen * sizeof(WCHAR));

+	ptr = block;

+	for(i=0; arg[i] != NULL; ++i){

+	    wcscpy(ptr, arg[i]);

+	    ptr += wcslen(ptr)+1;

+	}

+	*ptr = '\0';

+    }

+    return block;

+}