Implementation of putenv()

otethal · otethal · commit 0c34ea4bc1b9 · 2021-02-15T19:19:37.000+01:00
diff --git a/graalpython/com.oracle.graal.python.cext/posix/posix.c b/graalpython/com.oracle.graal.python.cext/posix/posix.c
@@ -53,6 +53,7 @@
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdint.h>
+#include <stdlib.h>
 #include <string.h>
 #include <sys/ioctl.h>
 #include <sys/stat.h>
@@ -483,6 +484,10 @@ int32_t call_ctermid(char *buf) {
     return ctermid(buf) == NULL ? -1 : 0;
 }
 
+int32_t call_setenv(char *name, char *value, int overwrite) {
+    return setenv(name, value, overwrite);
+}
+
 int32_t get_errno() {
     return errno;
 }
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/PosixModuleBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/PosixModuleBuiltins.java
@@ -60,6 +60,7 @@
 import com.oracle.graal.python.builtins.PythonBuiltins;
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.bytes.BytesNodes;
+import com.oracle.graal.python.builtins.objects.bytes.BytesUtils;
 import com.oracle.graal.python.builtins.objects.bytes.PBytes;
 import com.oracle.graal.python.builtins.objects.bytes.PBytesLike;
 import com.oracle.graal.python.builtins.objects.common.SequenceNodes.LenNode;
@@ -282,13 +283,24 @@ public void postInitialize(PythonCore core) {
         // fill the environ dictionary with the current environment
         Map<String, String> getenv = System.getenv();
         PDict environ = core.factory().createDict();
+        String pyenvLauncherKey = "__PYVENV_LAUNCHER__";
         for (Entry<String, String> entry : getenv.entrySet()) {
             String value;
-            if ("__PYVENV_LAUNCHER__".equals(entry.getKey())) {
+            if (pyenvLauncherKey.equals(entry.getKey())) {
                 // On Mac, the CPython launcher uses this env variable to specify the real Python
                 // executable. It will be honored by packages like "site". So, if it is set, we
                 // overwrite it with our executable to ensure that subprocesses will use us.
                 value = core.getContext().getOption(PythonOptions.Executable);
+
+                try {
+                    PosixSupportLibrary posixLib = PosixSupportLibrary.getUncached();
+                    Object posixSupport = core.getContext().getPosixSupport();
+                    Object k = posixLib.createPathFromString(posixSupport, pyenvLauncherKey);
+                    Object v = posixLib.createPathFromString(posixSupport, value);
+                    posixLib.setenv(posixSupport, k, v, true);
+                } catch (PosixException e) {
+                    // TODO handle error
+                }
             } else {
                 value = entry.getValue();
             }
@@ -318,6 +330,55 @@ public PTuple generic(VirtualFrame frame, Object cls, Object sequence, Object di
         }
     }
 
+    @Builtin(name = "putenv", minNumOfPositionalArgs = 2, parameterNames = {"name", "value"})
+    @ArgumentClinic(name = "name", conversionClass = FsConverterNode.class)
+    @ArgumentClinic(name = "value", conversionClass = FsConverterNode.class)
+    @GenerateNodeFactory
+    public abstract static class PutenvNode extends PythonBinaryClinicBuiltinNode {
+
+        @Override
+        protected ArgumentClinicProvider getArgumentClinic() {
+            return PosixModuleBuiltinsClinicProviders.PutenvNodeClinicProviderGen.INSTANCE;
+        }
+
+        @Specialization
+        PNone putenv(VirtualFrame frame, PBytes nameBytes, PBytes valueBytes,
+                        @Cached BytesNodes.ToBytesNode toBytesNode,
+                        @Cached SysModuleBuiltins.AuditNode auditNode,
+                        @CachedLibrary("getPosixSupport()") PosixSupportLibrary posixLib) {
+            // Unlike in other posix builtins, we go through str -> bytes -> byte[] -> String
+            // conversions for emulated backend because the bytes version after fsencode conversion
+            // is subject to sys.audit.
+            byte[] name = toBytesNode.execute(nameBytes);
+            byte[] value = toBytesNode.execute(valueBytes);
+            Object nameOpaque = checkNull(posixLib.createPathFromBytes(getPosixSupport(), name));
+            Object valueOpaque = checkNull(posixLib.createPathFromBytes(getPosixSupport(), value));
+            checkEqualSign(name);
+            auditNode.audit("os.putenv", nameBytes, valueBytes);
+            try {
+                posixLib.setenv(getPosixSupport(), nameOpaque, valueOpaque, true);
+            } catch (PosixException e) {
+                throw raiseOSErrorFromPosixException(frame, e);
+            }
+            return PNone.NONE;
+        }
+
+        private Object checkNull(Object value) {
+            if (value == null) {
+                throw raise(ValueError, ErrorMessages.EMBEDDED_NULL_BYTE);
+            }
+            return value;
+        }
+
+        private void checkEqualSign(byte[] bytes) {
+            for (byte b : bytes) {
+                if (b == '=') {
+                    throw raise(ValueError, ErrorMessages.ILLEGAL_ENVIRONMENT_VARIABLE_NAME);
+                }
+            }
+        }
+    }
+
     @Builtin(name = "execv", minNumOfPositionalArgs = 3, declaresExplicitSelf = true)
     @GenerateNodeFactory
     public abstract static class ExecvNode extends PythonBuiltinNode {
@@ -2057,6 +2118,29 @@ protected static boolean isPath(Object obj) {
     // ------------------
     // Helpers
 
+    /**
+     * Helper node that accepts either str or bytes and converts it to {@code PBytes}.
+     */
+    abstract static class StringOrBytesToBytesNode extends PythonBuiltinBaseNode {
+        abstract PBytes execute(Object obj);
+
+        @Specialization
+        PBytes doString(String str) {
+            return factory().createBytes(BytesUtils.utf8StringToBytes(str));
+        }
+
+        @Specialization
+        PBytes doPString(PString pstr,
+                        @Cached CastToJavaStringNode castToJavaStringNode) {
+            return doString(castToJavaStringNode.execute(pstr));
+        }
+
+        @Specialization
+        PBytes doBytes(PBytes bytes) {
+            return bytes;
+        }
+    }
+
     abstract static class ConvertToTimespecBaseNode extends PythonBuiltinBaseNode {
         abstract void execute(VirtualFrame frame, Object obj, long[] timespec, int offset);
     }
@@ -2213,6 +2297,20 @@ public static PBytes opaquePathToBytes(Object opaquePath, PosixSupportLibrary po
     // ------------------
     // Converters
 
+    public abstract static class FsConverterNode extends ArgumentCastNodeWithRaise {
+        @Specialization
+        PBytes convert(VirtualFrame frame, Object value,
+                        @Cached FspathNode fspathNode,
+                        @Cached StringOrBytesToBytesNode stringOrBytesToBytesNode) {
+            return stringOrBytesToBytesNode.execute(fspathNode.call(frame, value));
+        }
+
+        @ClinicConverterFactory
+        public static FsConverterNode create() {
+            return PosixModuleBuiltinsFactory.FsConverterNodeGen.create();
+        }
+    }
+
     /**
      * Equivalent of CPython's {@code path_converter()}. Always returns an {@code int}. If the
      * parameter is omitted, returns {@link PosixSupportLibrary#DEFAULT_DIR_FD}.
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/ErrorMessages.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/ErrorMessages.java
@@ -293,6 +293,7 @@ public abstract class ErrorMessages {
     public static final String IF_YOU_GIVE_ONLY_ONE_ARG_TO_DICT = "if you give only one argument to maketrans it must be a dict";
     public static final String INVALID_INDEXING_OF_0_DIM_MEMORY = "invalid indexing of 0-dim memory";
     public static final String ILLEGAL_ARG = "illegal argument";
+    public static final String ILLEGAL_ENVIRONMENT_VARIABLE_NAME = "illegal environment variable name";
     public static final String ILLEGAL_EXPRESSION_FOR_AUGMENTED_ASSIGNEMNT = "illegal expression for augmented assignment";
     public static final String ILLEGAL_IP_STRING_PASSED_TO = "illegal IP address string passed to %s";
     public static final String ILLEGAL_SOCKET_ADDR_ARG = "%s: illegal sockaddr argument";
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/EmulatedPosixSupport.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/EmulatedPosixSupport.java
@@ -92,6 +92,7 @@
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 
+import com.oracle.graal.python.builtins.objects.dict.PDict;
 import org.graalvm.nativeimage.ImageInfo;
 import org.graalvm.nativeimage.ProcessProperties;
 import org.graalvm.polyglot.io.ProcessHandler.Redirect;
@@ -235,12 +236,14 @@ public final class EmulatedPosixSupport extends PosixResources {
     private static final int S_IFREG = 0100000;
 
     private final PythonContext context;
+    private final Map<String, String> environ = new HashMap<>();
     private int currentUmask = 0022;
     private boolean hasDefaultUmask = true;
 
     public EmulatedPosixSupport(PythonContext context) {
         this.context = context;
         setEnv(context.getEnv());
+        environ.putAll(System.getenv());
     }
 
     @ExportMessage
@@ -1590,6 +1593,14 @@ public String ctermid() {
         return "/dev/tty";
     }
 
+    @ExportMessage
+    @TruffleBoundary
+    public synchronized void setenv(Object name, Object value, boolean overwrite) {
+        if (overwrite || !environ.containsKey(name)) {
+            environ.put((String) name, (String) value);
+        }
+    }
+
     @ExportMessage
     @TruffleBoundary
     public int forkExec(Object[] executables, Object[] args, Object cwd, Object[] env, int stdinReadFd, int stdinWriteFd, int stdoutReadFd, int stdoutWriteFd, int stderrReadFd, int stderrWriteFd,
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/LoggingPosixSupport.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/LoggingPosixSupport.java
@@ -696,6 +696,17 @@ final String ctermid(@CachedLibrary("this.delegate") PosixSupportLibrary lib) th
         }
     }
 
+    @ExportMessage
+    final void setenv(Object name, Object value, boolean overwrite,
+                      @CachedLibrary("this.delegate") PosixSupportLibrary lib) throws PosixException {
+        logEnter("setenv", "%s, %s, %b", name, value, overwrite);
+        try {
+            lib.setenv(delegate, name, value, overwrite);
+        } catch (PosixException e) {
+            throw logException("setenv", e);
+        }
+    }
+
     @ExportMessage
     final int forkExec(Object[] executables, Object[] args, Object cwd, Object[] env, int stdinReadFd, int stdinWriteFd, int stdoutReadFd, int stdoutWriteFd, int stderrReadFd, int stderrWriteFd,
                     int errPipeReadFd, int errPipeWriteFd, boolean closeFds, boolean restoreSignals, boolean callSetsid, int[] fdsToKeep,
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/NFIPosixSupport.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/NFIPosixSupport.java
@@ -153,6 +153,7 @@ private enum PosixNativeFunction {
         call_getppid("():sint64"),
         call_getsid("(sint64):sint64"),
         call_ctermid("([sint8]):sint32"),
+        call_setenv("([sint8], [sint8], sint32):sint32"),
         fork_exec("([sint8], [sint64], sint32, sint32, sint32, sint32, sint32, sint32, sint32, sint32, sint32, sint32, sint32, sint32, sint32, sint32, sint32, [sint32], sint64):sint32");
 
         private final String signature;
@@ -926,6 +927,15 @@ public String ctermid(@Shared("invoke") @Cached InvokeNativeFunction invokeNode)
         return cStringToJavaString(buf);
     }
 
+    @ExportMessage
+    public void setenv(Object name, Object value, boolean overwrite,
+                    @Shared("invoke") @Cached InvokeNativeFunction invokeNode) throws PosixException {
+        int res = invokeNode.callInt(this, PosixNativeFunction.call_setenv, pathToCString(name), pathToCString(value), overwrite ? 1 : 0);
+        if (res == -1) {
+            throw getErrnoAndThrowPosixException(invokeNode);
+        }
+    }
+
     @ExportMessage
     public int forkExec(Object[] executables, Object[] args, Object cwd, Object[] env, int stdinReadFd, int stdinWriteFd, int stdoutReadFd, int stdoutWriteFd, int stderrReadFd, int stderrWriteFd,
                     int errPipeReadFd, int errPipeWriteFd, boolean closeFds, boolean restoreSignals, boolean callSetsid, int[] fdsToKeep,
@@ -1102,6 +1112,9 @@ private static Buffer checkPath(byte[] path) {
                 return null;
             }
         }
+        // TODO we keep a byte[] provided by the caller, who can potentially change it, making our
+        // check for embedded nulls pointless. Maybe we should copy it and while on it, might as
+        // well add the terminating null character, avoiding the copy we do later in pathToCString.
         return Buffer.wrap(path);
     }
 
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/PosixSupportLibrary.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/PosixSupportLibrary.java
@@ -273,6 +273,10 @@ public abstract class PosixSupportLibrary extends Library {
 
     public abstract String ctermid(Object receiver) throws PosixException;
 
+    // note: this leaks memory in nfi backend and is not synchronized
+    // TODO is it worth synchronizing at least all accesses made through PosixSupportLibrary?
+    public abstract void setenv(Object receiver, Object name, Object value, boolean overwrite) throws PosixException;
+
     public abstract int forkExec(Object receiver, Object[] executables, Object[] args, Object cwd, Object[] env, int stdinReadFd, int stdinWriteFd, int stdoutReadFd, int stdoutWriteFd,
                     int stderrReadFd, int stderrWriteFd, int errPipeReadFd, int errPipeWriteFd, boolean closeFds, boolean restoreSignals, boolean callSetsid, int[] fdsToKeep) throws PosixException;
 
