Merge branch 'pan/unicode_home/OTP-10160' into maint

* pan/unicode_home/OTP-10160:
  Teach release_handler_SUITE about file:native_name_encoding/0
  Add documetation about Unicode in environment
  Make get/putenv and erlexec understand Unicode

11 files changed, 185 insertions, 116 deletions

diff --git a/erts/emulator/beam/break.c b/erts/emulator/beam/break.c
index 6f5020dc14..93aa2fb8d0 100644
--- a/erts/emulator/beam/break.c
+++ b/erts/emulator/beam/break.c
@@ -678,7 +678,7 @@ erl_crash_dump_v(char *file, int line, char* fmt, va_list args)
 
     erts_sys_prepare_crash_dump();
 
-    if (erts_sys_getenv("ERL_CRASH_DUMP",&dumpnamebuf[0],&dumpnamebufsize) != 0)
+    if (erts_sys_getenv_raw("ERL_CRASH_DUMP",&dumpnamebuf[0],&dumpnamebufsize) != 0)
 	dumpname = "erl_crash.dump";
     else
 	dumpname = &dumpnamebuf[0];
diff --git a/erts/emulator/beam/dist.c b/erts/emulator/beam/dist.c
index 01fd63d5d9..025258e8de 100644
--- a/erts/emulator/beam/dist.c
+++ b/erts/emulator/beam/dist.c
@@ -968,16 +968,16 @@ erts_dsig_send_group_leader(ErtsDSigData *dsdp, Eterm leader, Eterm remote)
 #define VALGRIND_PRINTF_XML VALGRIND_PRINTF
 #endif
 
-#  define PURIFY_MSG(msg)                                                \
-    do {								 \
-	char buf__[1]; size_t bufsz__ = sizeof(buf__);			 \
-	if (erts_sys_getenv("VALGRIND_LOG_XML", buf__, &bufsz__) >= 0) { \
-	    VALGRIND_PRINTF_XML("<erlang_error_log>"			 \
-			    "%s, line %d: %s</erlang_error_log>\n",	 \
-			    __FILE__, __LINE__, msg);			 \
-	} else {							 \
-	    VALGRIND_PRINTF("%s, line %d: %s", __FILE__, __LINE__, msg); \
-	}								 \
+#  define PURIFY_MSG(msg)                                                    \
+    do {								     \
+	char buf__[1]; size_t bufsz__ = sizeof(buf__);			     \
+	if (erts_sys_getenv_raw("VALGRIND_LOG_XML", buf__, &bufsz__) >= 0) { \
+	    VALGRIND_PRINTF_XML("<erlang_error_log>"			     \
+			    "%s, line %d: %s</erlang_error_log>\n",	     \
+			    __FILE__, __LINE__, msg);			     \
+	} else {							     \
+	    VALGRIND_PRINTF("%s, line %d: %s", __FILE__, __LINE__, msg);     \
+	}								     \
     } while (0)
 #else
 #  define PURIFY_MSG(msg)
diff --git a/erts/emulator/beam/erl_bif_info.c b/erts/emulator/beam/erl_bif_info.c
index f56b00287f..45dc5fb11c 100755
--- a/erts/emulator/beam/erl_bif_info.c
+++ b/erts/emulator/beam/erl_bif_info.c
@@ -1697,7 +1697,7 @@ static int check_if_xml(void)
 {
     char buf[1];
     size_t bufsz = sizeof(buf);
-    return erts_sys_getenv("VALGRIND_LOG_XML", buf, &bufsz) >= 0;
+    return erts_sys_getenv_raw("VALGRIND_LOG_XML", buf, &bufsz) >= 0;
 }
 #else
 #define check_if_xml() 0
diff --git a/erts/emulator/beam/erl_bif_os.c b/erts/emulator/beam/erl_bif_os.c
index 58d48199fa..d076640a8b 100644
--- a/erts/emulator/beam/erl_bif_os.c
+++ b/erts/emulator/beam/erl_bif_os.c
@@ -71,15 +71,13 @@ BIF_RETTYPE os_getenv_0(BIF_ALIST_0)
     Eterm* hp;
     Eterm ret;
     Eterm str;
-    int len;
 
     init_getenv_state(&state);
 
     ret = NIL;
     while ((cp = getenv_string(&state)) != NULL) {
-	len = strlen(cp);
-	hp = HAlloc(BIF_P, len*2+2);
-	str = buf_to_intlist(&hp, cp, len, NIL);
+	str = erts_convert_native_to_filename(BIF_P,(byte *)cp);
+	hp = HAlloc(BIF_P, 2);
 	ret = CONS(hp, str, ret);
     }
 
@@ -88,32 +86,30 @@ BIF_RETTYPE os_getenv_0(BIF_ALIST_0)
     return ret;
 }
 
-
+#define STATIC_BUF_SIZE 1024
 BIF_RETTYPE os_getenv_1(BIF_ALIST_1)
 {
     Process* p = BIF_P;
-    Eterm key = BIF_ARG_1;
     Eterm str;
-    int len, res;
+    Sint len;
+    int res;
     char *key_str, *val;
-    char buf[1024];
+    char buf[STATIC_BUF_SIZE];
     size_t val_size = sizeof(buf);
 
-    len = is_string(key);
-    if (!len) {
+    key_str = erts_convert_filename_to_native(BIF_ARG_1,buf,STATIC_BUF_SIZE,
+					      ERTS_ALC_T_TMP,1,0,&len);
+
+    if (!key_str) {
 	BIF_ERROR(p, BADARG);
     }
-    /* Leave at least one byte in buf for value */
-    key_str = len < sizeof(buf)-2 ? &buf[0] : erts_alloc(ERTS_ALC_T_TMP, len+1);
-    if (intlist_to_buf(key, key_str, len) != len)
-	erl_exit(1, "%s:%d: Internal error\n", __FILE__, __LINE__);
-    key_str[len] = '\0';
 
     if (key_str != &buf[0])
 	val = &buf[0];
     else {
-	val_size -= len + 1;
-	val = &buf[len + 1];
+	/* len includes zero byte */
+	val_size -= len;
+	val = &buf[len];
     }
     res = erts_sys_getenv(key_str, val, &val_size);
 
@@ -121,7 +117,6 @@ BIF_RETTYPE os_getenv_1(BIF_ALIST_1)
     no_var:
 	str = am_false;
     } else {
-	Eterm* hp;
 	if (res > 0) {
 	    val = erts_alloc(ERTS_ALC_T_TMP, val_size);
 	    while (1) {
@@ -134,9 +129,7 @@ BIF_RETTYPE os_getenv_1(BIF_ALIST_1)
 		    val = erts_realloc(ERTS_ALC_T_TMP, val, val_size);
 	    }
 	}
-	if (val_size)
-	    hp = HAlloc(p, val_size*2);
-	str = buf_to_intlist(&hp, val, val_size, NIL);
+	str = erts_convert_native_to_filename(p,(byte *)val);
     }
     if (key_str != &buf[0])
 	erts_free(ERTS_ALC_T_TMP, key_str);
@@ -147,46 +140,43 @@ BIF_RETTYPE os_getenv_1(BIF_ALIST_1)
 
 BIF_RETTYPE os_putenv_2(BIF_ALIST_2)
 {
-    Process* p = BIF_P;
-    Eterm key = BIF_ARG_1;
-    Eterm value = BIF_ARG_2;
-    char def_buf[1024];
-    char *buf = NULL;
-    int sep_ix, i, key_len, value_len, tot_len;
-    key_len = is_string(key);
-    if (!key_len) {
-    error:
-	if (buf)
-	    erts_free(ERTS_ALC_T_TMP, (void *) buf);
-	BIF_ERROR(p, BADARG);
+    char def_buf_key[STATIC_BUF_SIZE];
+    char def_buf_value[STATIC_BUF_SIZE];
+    char *key_buf, *value_buf;
+
+    key_buf = erts_convert_filename_to_native(BIF_ARG_1,def_buf_key,
+					      STATIC_BUF_SIZE,
+					      ERTS_ALC_T_TMP,0,0,NULL);
+    if (!key_buf) {
+	BIF_ERROR(BIF_P, BADARG);
     }
-    if (is_nil(value))
-	value_len = 0;
-    else {
-	value_len = is_string(value);
-	if (!value_len)
-	    goto error;
+    value_buf = erts_convert_filename_to_native(BIF_ARG_2,def_buf_value,
+						STATIC_BUF_SIZE,
+						ERTS_ALC_T_TMP,1,0,
+						NULL);
+    if (!value_buf) {
+	if (key_buf != def_buf_key) {
+	    erts_free(ERTS_ALC_T_TMP, key_buf);
+	}
+	BIF_ERROR(BIF_P, BADARG);
+    }
+	    
+
+    if (erts_sys_putenv(key_buf, value_buf)) {
+	if (key_buf != def_buf_key) {
+	    erts_free(ERTS_ALC_T_TMP, key_buf);
+	}
+	if (value_buf != def_buf_value) {
+	    erts_free(ERTS_ALC_T_TMP, value_buf);
+	}
+	BIF_ERROR(BIF_P, BADARG);
+    }
+    if (key_buf != def_buf_key) {
+	erts_free(ERTS_ALC_T_TMP, key_buf);
     }
-    tot_len = key_len + 1 + value_len + 1;
-    if (tot_len <= sizeof(def_buf))
-	buf = &def_buf[0];
-    else
-	buf = erts_alloc(ERTS_ALC_T_TMP, tot_len);
-    i = intlist_to_buf(key, buf, key_len);
-    if (i != key_len)
-	erl_exit(1, "%s:%d: Internal error\n", __FILE__, __LINE__);	
-    sep_ix = i;
-    buf[i++] = '=';
-    if (is_not_nil(value))
-	i += intlist_to_buf(value, &buf[i], value_len);
-    if (i != key_len + 1 + value_len)
-	erl_exit(1, "%s:%d: Internal error\n", __FILE__, __LINE__);	
-    buf[i] = '\0';
-    if (erts_sys_putenv(buf, sep_ix)) {
-	goto error;
+    if (value_buf != def_buf_value) {
+	erts_free(ERTS_ALC_T_TMP, value_buf);
     }
-    if (buf != &def_buf[0])
-	erts_free(ERTS_ALC_T_TMP, (void *) buf);
     BIF_RET(am_true);
 }
 
diff --git a/erts/emulator/beam/erl_bif_port.c b/erts/emulator/beam/erl_bif_port.c
index 2a1b01b107..f9009166c0 100644
--- a/erts/emulator/beam/erl_bif_port.c
+++ b/erts/emulator/beam/erl_bif_port.c
@@ -718,7 +718,7 @@ open_port(Process* p, Eterm name, Eterm settings, int *err_nump)
 		} else if (option == am_arg0) {
 		    char *a0;
 
-		    if ((a0 = erts_convert_filename_to_native(*tp, ERTS_ALC_T_TMP, 1)) == NULL) {
+		    if ((a0 = erts_convert_filename_to_native(*tp, NULL, 0, ERTS_ALC_T_TMP, 1, 1, NULL)) == NULL) {
 			goto badarg;
 		    }
 		    if (opts.argv == NULL) {
@@ -845,7 +845,7 @@ open_port(Process* p, Eterm name, Eterm settings, int *err_nump)
 		goto badarg;
 	    }
 	    name = tp[1];
-	    if ((name_buf = erts_convert_filename_to_native(name,ERTS_ALC_T_TMP,0)) == NULL) {
+	    if ((name_buf = erts_convert_filename_to_native(name, NULL, 0, ERTS_ALC_T_TMP,0,1, NULL)) == NULL) {
 		goto badarg;
 	    }
 	    opts.spawn_type = ERTS_SPAWN_EXECUTABLE;
@@ -909,7 +909,7 @@ open_port(Process* p, Eterm name, Eterm settings, int *err_nump)
 	    }
 	    opts.wd = (char *) dir;
 	} else {
-	    if ((opts.wd = erts_convert_filename_to_native(edir,ERTS_ALC_T_TMP,0)) == NULL) {
+	    if ((opts.wd = erts_convert_filename_to_native(edir, NULL, 0, ERTS_ALC_T_TMP,0,1,NULL)) == NULL) {
 		goto badarg;
 	    }
 	}
@@ -1000,7 +1000,7 @@ static char **convert_args(Eterm l)
     pp[i++] = erts_default_arg0;
     while (is_list(l)) {
 	str = CAR(list_val(l));
-	if ((b = erts_convert_filename_to_native(str,ERTS_ALC_T_TMP,1)) == NULL) {
+	if ((b = erts_convert_filename_to_native(str,NULL,0,ERTS_ALC_T_TMP,1,1,NULL)) == NULL) {
 	    int j;
 	    for (j = 1; j < i; ++j)
 		erts_free(ERTS_ALC_T_TMP, pp[j]);
@@ -1035,8 +1035,9 @@ static byte* convert_environment(Process* p, Eterm env)
     Eterm* hp;
     Uint heap_size;
     int n;
-    Uint size;
+    Sint size;
     byte* bytes;
+    int encoding = erts_get_native_filename_encoding();
 
     if ((n = list_length(env)) < 0) {
 	return NULL;
@@ -1079,7 +1080,8 @@ static byte* convert_environment(Process* p, Eterm env)
     if (is_not_nil(env)) {
 	goto done;
     }
-    if (erts_iolist_size(all, &size)) {
+
+    if ((size = erts_native_filename_need(all,encoding)) < 0) {
 	goto done;
     }
 
@@ -1087,7 +1089,7 @@ static byte* convert_environment(Process* p, Eterm env)
      * Put the result in a binary (no risk for a memory leak that way).
      */
     (void) erts_new_heap_binary(p, NULL, size, &bytes);
-    io_list_to_buf(all, (char*)bytes, size);
+    erts_native_filename_put(all,encoding,bytes);
 
  done:
     erts_free(ERTS_ALC_T_TMP, temp_heap);
diff --git a/erts/emulator/beam/erl_init.c b/erts/emulator/beam/erl_init.c
index 02164728fe..1eb3dba240 100644
--- a/erts/emulator/beam/erl_init.c
+++ b/erts/emulator/beam/erl_init.c
@@ -623,7 +623,7 @@ early_init(int *argc, char **argv) /*
 
     envbufsz = sizeof(envbuf);
 
-    /* erts_sys_getenv() not initialized yet; need erts_sys_getenv__() */
+    /* erts_sys_getenv(_raw)() not initialized yet; need erts_sys_getenv__() */
     if (erts_sys_getenv__("ERL_THREAD_POOL_SIZE", envbuf, &envbufsz) == 0)
 	erts_async_max_threads = atoi(envbuf);
     else
@@ -846,13 +846,13 @@ erl_start(int argc, char **argv)
     int ncpu = early_init(&argc, argv);
 
     envbufsz = sizeof(envbuf);
-    if (erts_sys_getenv(ERL_MAX_ETS_TABLES_ENV, envbuf, &envbufsz) == 0)
+    if (erts_sys_getenv_raw(ERL_MAX_ETS_TABLES_ENV, envbuf, &envbufsz) == 0)
 	user_requested_db_max_tabs = atoi(envbuf);
     else
 	user_requested_db_max_tabs = 0;
 
     envbufsz = sizeof(envbuf);
-    if (erts_sys_getenv("ERL_FULLSWEEP_AFTER", envbuf, &envbufsz) == 0) {
+    if (erts_sys_getenv_raw("ERL_FULLSWEEP_AFTER", envbuf, &envbufsz) == 0) {
 	Uint16 max_gen_gcs = atoi(envbuf);
 	erts_smp_atomic32_set_nob(&erts_max_gen_gcs,
 				  (erts_aint32_t) max_gen_gcs);
diff --git a/erts/emulator/beam/erl_unicode.c b/erts/emulator/beam/erl_unicode.c
index 6d5eae73b0..127db4d4f6 100644
--- a/erts/emulator/beam/erl_unicode.c
+++ b/erts/emulator/beam/erl_unicode.c
@@ -2027,12 +2027,14 @@ BIF_RETTYPE binary_to_existing_atom_2(BIF_ALIST_2)
  * string routines, that will certainly fail on some OS.
  */
 
-char *erts_convert_filename_to_native(Eterm name, ErtsAlcType_t alloc_type, int allow_empty)
+char *erts_convert_filename_to_native(Eterm name, char *statbuf, size_t statbuf_size, ErtsAlcType_t alloc_type, int allow_empty, int allow_atom, Sint *used)
 {
     int encoding = erts_get_native_filename_encoding();
     char* name_buf = NULL;
 
-    if (is_atom(name) || is_list(name) || (allow_empty && is_nil(name))) {
+    if ((allow_atom && is_atom(name)) || 
+	is_list(name) || 
+	(allow_empty && is_nil(name))) {
 	Sint need;
 	if ((need = erts_native_filename_need(name,encoding)) < 0) {
 	    return NULL;
@@ -2042,7 +2044,13 @@ char *erts_convert_filename_to_native(Eterm name, ErtsAlcType_t alloc_type, int
 	} else {
 	    ++need;
 	}
-	name_buf = (char *) erts_alloc(alloc_type, need);
+	if (used) 
+	    *used = (Sint) need;
+	if (need > statbuf_size) {
+	    name_buf = (char *) erts_alloc(alloc_type, need);
+	} else {
+	    name_buf = statbuf;
+	}
 	erts_native_filename_put(name,encoding,(byte *)name_buf); 
 	name_buf[need-1] = 0;
 	if (encoding == ERL_FILENAME_WIN_WCHAR) {
@@ -2058,14 +2066,26 @@ char *erts_convert_filename_to_native(Eterm name, ErtsAlcType_t alloc_type, int
 	bytes = erts_get_aligned_binary_bytes(name, &temp_alloc);
 	if (encoding != ERL_FILENAME_WIN_WCHAR) {
 	    /*Add 0 termination only*/
-	    name_buf = (char *) erts_alloc(alloc_type, size+1);
+	    if (used) 
+		*used = (Sint) size+1;
+	    if (size+1 > statbuf_size) {
+		name_buf = (char *) erts_alloc(alloc_type, size+1);
+	    } else {
+		name_buf = statbuf;
+	    }
 	    memcpy(name_buf,bytes,size);
 	    name_buf[size]=0;
 	} else if (erts_analyze_utf8(bytes,size,&err_pos,&num_chars,NULL) != ERTS_UTF8_OK || 
 		   erts_get_user_requested_filename_encoding() ==  ERL_FILENAME_LATIN1) {
 	    byte *p;
 	    /* What to do now? Maybe latin1, so just take byte for byte instead */
-	    name_buf = (char *) erts_alloc(alloc_type, (size+1)*2);
+	    if (used) 
+		*used = (Sint) (size+1)*2;
+	    if ((size+1)*2 > statbuf_size) {
+		name_buf = (char *) erts_alloc(alloc_type, (size+1)*2);
+	    } else {
+		name_buf = statbuf;
+	    }
 	    p = (byte *) name_buf;
 	    while (size--) {
 		*p++ = *bytes++;
@@ -2074,7 +2094,13 @@ char *erts_convert_filename_to_native(Eterm name, ErtsAlcType_t alloc_type, int
 	    *p++ = 0;
 	    *p++ = 0;
 	} else { /* WIN_WCHAR and valid UTF8 */
-	    name_buf = (char *) erts_alloc(alloc_type, (num_chars+1)*2);
+	    if (used) 
+		*used = (Sint) (num_chars+1)*2;
+	    if ((num_chars+1)*2 > statbuf_size) {
+		name_buf = (char *) erts_alloc(alloc_type, (num_chars+1)*2);
+	    } else {
+		name_buf = statbuf;
+	    }
 	    erts_copy_utf8_to_utf16_little((byte *) name_buf, bytes, num_chars);
 	    name_buf[num_chars*2] = 0;
 	    name_buf[num_chars*2+1] = 0;
@@ -2086,6 +2112,71 @@ char *erts_convert_filename_to_native(Eterm name, ErtsAlcType_t alloc_type, int
     return name_buf;
 }
 
+static int filename_len_16bit(byte *str) 
+{
+    byte *p = str;
+    while(*p != '\0' || p[1] != '\0') {
+	p += 2;
+    }
+    return (p - str);
+}
+Eterm erts_convert_native_to_filename(Process *p, byte *bytes)
+{
+    Uint size,num_chars;
+    Eterm *hp;
+    byte *err_pos;
+    Uint num_built; /* characters */
+    Uint num_eaten; /* bytes */
+    Eterm ret;
+    int mac = 0;
+
+    switch (erts_get_native_filename_encoding()) {
+    case ERL_FILENAME_LATIN1:
+	goto noconvert;
+    case ERL_FILENAME_UTF8_MAC:
+	mac = 1;
+    case ERL_FILENAME_UTF8:
+	size = strlen((char *) bytes);
+	if (erts_analyze_utf8(bytes,size,&err_pos,&num_chars,NULL) != ERTS_UTF8_OK) {
+	    goto noconvert;
+	}
+	num_built = 0;
+	num_eaten = 0;
+	if (mac) {
+	    ret = do_utf8_to_list_normalize(p, num_chars, bytes, size);
+	} else {
+	    ret = do_utf8_to_list(p, num_chars, bytes, size, num_chars, &num_built, &num_eaten, NIL);
+	} 
+	return ret;
+    case ERL_FILENAME_WIN_WCHAR:
+	size=filename_len_16bit(bytes);
+	if ((size % 2) != 0) { /* Panic fixup to avoid crashing the emulator */
+	    size--;
+	    hp = HAlloc(p, size+2);
+	    ret = CONS(hp,make_small((Uint) bytes[size]),NIL);
+	    hp += 2;
+	} else {
+	    hp = HAlloc(p, size);
+	    ret = NIL;
+	}
+	bytes += size-1;
+	while (size > 0) {
+	    Uint x = ((Uint) *bytes--) << 8;
+	    x |= ((Uint) *bytes--);
+	    size -= 2;
+	    ret = CONS(hp,make_small(x),ret);
+	    hp += 2;
+	}	    
+	return ret;
+    default:
+	goto noconvert;
+    }
+ noconvert:
+    size = strlen((char *) bytes);
+    hp = HAlloc(p, 2 * size);
+    return erts_bin_bytes_to_list(NIL, hp, bytes, size, 0);
+}
+
 
 Sint erts_native_filename_need(Eterm ioterm, int encoding) 
 {
@@ -2619,3 +2710,4 @@ BIF_RETTYPE file_native_name_encoding_0(BIF_ALIST_0)
 	BIF_RET(am_undefined);
     }
 }
+
diff --git a/erts/emulator/beam/global.h b/erts/emulator/beam/global.h
index 1b15c4ac3b..dbf95f5bd7 100755
--- a/erts/emulator/beam/global.h
+++ b/erts/emulator/beam/global.h
@@ -1386,8 +1386,12 @@ Sint erts_native_filename_need(Eterm ioterm, int encoding);
 void erts_copy_utf8_to_utf16_little(byte *target, byte *bytes, int num_chars);
 int erts_analyze_utf8(byte *source, Uint size, 
 			byte **err_pos, Uint *num_chars, int *left);
-char *erts_convert_filename_to_native(Eterm name, ErtsAlcType_t alloc_type, int allow_empty);
-
+char *erts_convert_filename_to_native(Eterm name, char *statbuf, 
+				      size_t statbuf_size, 
+				      ErtsAlcType_t alloc_type, 
+				      int allow_empty, int allow_atom,
+				      Sint *used /* out */);
+Eterm erts_convert_native_to_filename(Process *p, byte *bytes);
 #define ERTS_UTF8_OK 0
 #define ERTS_UTF8_INCOMPLETE 1
 #define ERTS_UTF8_ERROR 2
diff --git a/erts/emulator/beam/io.c b/erts/emulator/beam/io.c
index 204bff299e..35b194f927 100644
--- a/erts/emulator/beam/io.c
+++ b/erts/emulator/beam/io.c
@@ -1314,7 +1314,7 @@ void init_io(void)
 
     pdl_init();
 
-    if (erts_sys_getenv("ERL_MAX_PORTS", maxports, &maxportssize) == 0) 
+    if (erts_sys_getenv_raw("ERL_MAX_PORTS", maxports, &maxportssize) == 0) 
 	erts_max_ports = atoi(maxports);
     else
 	erts_max_ports = sys_max_files();
@@ -5227,11 +5227,11 @@ int null_func(void)
 int
 erl_drv_putenv(char *key, char *value)
 {
-    return erts_write_env(key, value);
+    return erts_sys_putenv_raw(key, value);
 }
 
 int
 erl_drv_getenv(char *key, char *value, size_t *value_size)
 {
-    return erts_sys_getenv(key, value, value_size);
+    return erts_sys_getenv_raw(key, value, value_size);
 }
diff --git a/erts/emulator/beam/sys.h b/erts/emulator/beam/sys.h
index 7b2bb81f62..2406c52f14 100644
--- a/erts/emulator/beam/sys.h
+++ b/erts/emulator/beam/sys.h
@@ -703,18 +703,21 @@ int sys_double_to_chars(double, char*);
 void sys_get_pid(char *);
 
 /* erts_sys_putenv() returns, 0 on success and a value != 0 on failure. */
-int erts_sys_putenv(char *key_value, int sep_ix);
+int erts_sys_putenv(char *key, char *value);
+/* Simple variant used from drivers, raw eightbit interface */
+int erts_sys_putenv_raw(char *key, char *value);
 /* erts_sys_getenv() returns 0 on success (length of value string in
    *size), a value > 0 if value buffer is too small (*size is set to needed
    size), and a value < 0 on failure. */
 int erts_sys_getenv(char *key, char *value, size_t *size);
+/* Simple variant used from drivers, raw eightbit interface */
+int erts_sys_getenv_raw(char *key, char *value, size_t *size);
 /* erts_sys_getenv__() is only allowed to be used in early init phase */
 int erts_sys_getenv__(char *key, char *value, size_t *size);
 
 /* Easier to use, but not as efficient, environment functions */
 char *erts_read_env(char *key);
 void erts_free_read_env(void *value);
-int erts_write_env(char *key, char *value);
 
 /* utils.c */
 
diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index a36d15204e..bd708ceee6 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -3409,7 +3409,7 @@ erts_read_env(char *key)
     char *value = erts_alloc(ERTS_ALC_T_TMP, value_len);
     int res;
     while (1) {
-	res = erts_sys_getenv(key, value, &value_len);
+	res = erts_sys_getenv_raw(key, value, &value_len);
 	if (res <= 0)
 	    break;
 	value = erts_realloc(ERTS_ALC_T_TMP, value, value_len);
@@ -3428,28 +3428,6 @@ erts_free_read_env(void *value)
 	erts_free(ERTS_ALC_T_TMP, value);
 }
 
-int
-erts_write_env(char *key, char *value)
-{
-    int ix, res;
-    size_t key_len = sys_strlen(key), value_len = sys_strlen(value);
-    char *key_value = erts_alloc_fnf(ERTS_ALC_T_TMP,
-				     key_len + 1 + value_len + 1);
-    if (!key_value) {
-	errno = ENOMEM;
-	return -1;
-    }
-    sys_memcpy((void *) key_value, (void *) key, key_len);
-    ix = key_len;
-    key_value[ix++] = '=';
-    sys_memcpy((void *) key_value, (void *) value, value_len);
-    ix += value_len;
-    key_value[ix] = '\0';
-    res = erts_sys_putenv(key_value, key_len);
-    erts_free(ERTS_ALC_T_TMP, key_value);
-    return res;
-}
-
 /*
  * To be used to silence unused result warnings, but do not abuse it.
  */