This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Improved $^X absolute pathname conversion.
authorH.Merijn Brand <merijn@lx09.procura.nl>
Sat, 1 Oct 2011 10:37:08 +0000 (12:37 +0200)
committerH.Merijn Brand <merijn@lx09.procura.nl>
Sat, 1 Oct 2011 10:37:08 +0000 (12:37 +0200)
Backport of 6f31bef90fda3b9a8027adfb123055bc0eefc81c

Signed-off-by: H.Merijn Brand <merijn@lx09.procura.nl>
U/perl/d_procselfexe.U
U/perl/usekernprocpathname.U [new file with mode: 0644]
U/perl/usensgetexecutablepath.U [new file with mode: 0644]

index d5de2f9..7958a9e 100644 (file)
 ?H:?%<:#define PROCSELFEXE_PATH        $procselfexe    /**/
 ?H:?%<:#endif
 ?H:.
+?T:try type
 ?LINT: set d_procselfexe
 : Check if exe is symlink to abs path of executing program
 echo " "
 procselfexe=''
 val="$undef"
 case "$d_readlink" in
-"$define")
-       if $issymlink /proc/self/exe ; then
-               $ls -l /proc/self/exe > reflect
+    "$define")
+       : NetBSD first as /proc/self is a symlink to /proc/curproc, and it feels
+       : more tidy to avoid an extra level of symlink
+       set NetBSD /proc/curproc/exe Linux /proc/self/exe FreeBSD /proc/curproc/file Solaris /proc/self/path/a.out
+       while test $# -gt 0; do
+           type=$1; try=$2
+           shift; shift
+           if $issymlink $try; then
+               $ls -l $try > reflect
                if $contains /`basename $ls` reflect >/dev/null 2>&1; then
-                       echo "You have Linux-like /proc/self/exe."
-                       procselfexe='"/proc/self/exe"'
-                       val="$define"
+                   echo "You have $type-like $try."
+                   procselfexe='"'$try'"'
+                   val="$define"
+                   : This will break out of the loop
+                   set X; shift
                fi
-       fi
-       if $issymlink /proc/curproc/file ; then
-               $ls -l /proc/curproc/file > reflect
-               if $contains /`basename $ls` reflect >/dev/null 2>&1; then
-                       echo "You have BSD-like /proc/curproc/file."
-                       procselfexe='"/proc/curproc/file"'
-                       val="$define"
-               fi
-       fi
+           fi
+       done
        ;;
 esac
 $rm -f reflect
diff --git a/U/perl/usekernprocpathname.U b/U/perl/usekernprocpathname.U
new file mode 100644 (file)
index 0000000..2b29882
--- /dev/null
@@ -0,0 +1,131 @@
+?MAKE:usekernprocpathname: cat rm_try Compile run Setvar
+?MAKE: -pick add $@ %<
+?S:usekernprocpathname:
+?S:    This variable, indicates that we can use sysctl with
+?S:    KERN_PROC_PATHNAME to get a full path for the executable, and hence
+?S:    convert $^X to an absolute path.
+?S:.
+?C:USE_KERN_PROC_PATHNAME:
+?C:    This symbol, if defined, indicates that we can use sysctl with
+?C:    KERN_PROC_PATHNAME to get a full path for the executable, and hence
+?C:    convert $^X to an absolute path.
+?C:.
+?H:#$usekernprocpathname USE_KERN_PROC_PATHNAME        /**/
+?H:.
+?LINT:set usekernprocpathname
+?F:!try
+: Determine if we can use sysctl with KERN_PROC_PATHNAME to find executing program
+echo " "
+echo "Determining whether we can use sysctl with KERN_PROC_PATHNAME to find executing program..." >&4
+$cat >try.c <<'EOM'
+/* Intentionally a long probe as I'd like to sanity check that the exact
+   approach is going to work, as thinking it will work, but only having it
+   part working at runtime is worse than not having it.  */
+
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <sys/param.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int
+main(int argc, char **argv) {
+    char *buffer;
+    char *argv_leaf = strrchr(argv[0], '/');
+    char *buffer_leaf;
+    size_t size = 0;
+    int mib[4];
+
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROC;
+    mib[2] = KERN_PROC_PATHNAME;
+    mib[3] = -1;
+
+    if (!argv_leaf) {
+       fprintf(stderr, "Can't locate / in '%s'\n", argv[0]);
+       return 1;
+    }
+
+    if (sysctl(mib, 4, NULL, &size, NULL, 0)) {
+       perror("sysctl");
+       return 2;
+    }
+
+    if (size < strlen(argv_leaf) + 1) {
+       fprintf(stderr, "size %lu is too short for a path\n",
+               (unsigned long) size);
+       return 3;
+    }
+
+    if (size > MAXPATHLEN * MAXPATHLEN) {
+       fprintf(stderr, "size %lu is too long for a path\n",
+               (unsigned long) size);
+       return 4;
+    }
+
+    buffer = malloc(size);
+    if (!buffer) {
+       perror("malloc");
+       return 5;
+    }
+
+    if (sysctl(mib, 4, buffer, &size, NULL, 0)) {
+       perror("sysctl");
+       return 6;
+    }
+
+    if (strlen(buffer) + 1 != size) {
+       fprintf(stderr, "size != strlen(buffer) + 1 (%lu != %lu)\n",
+               (unsigned long)size, (unsigned long)strlen(buffer) + 1);
+        return 7;
+    }
+
+
+    if (*buffer != '/') {
+       fprintf(stderr, "Not an absolute path: '%s'\n", buffer);
+       return 8;
+    }
+
+    if (strstr(buffer, "/./")) {
+       fprintf(stderr, "Contains /./: '%s'\n", buffer);
+       return 9;
+    }
+
+    if (strstr(buffer, "/../")) {
+       fprintf(stderr, "Contains /../: '%s'\n", buffer);
+       return 10;
+    }
+
+    buffer_leaf = strrchr(buffer, '/');
+    if (strcmp(buffer_leaf, argv_leaf) != 0) {
+       fprintf(stderr, "Leafnames differ: '%s' vs '%s'\n", argv[0], buffer);
+       return 11;
+    }
+
+    free(buffer);
+
+    return 0;
+}
+EOM
+
+val=$undef
+set try
+if eval $compile_ok; then
+       if $run ./try; then
+               echo "You can use sysctl with KERN_PROC_PATHNAME to find the executing program." >&4
+               val="$define"
+       else
+               echo "Nope, sysctl with KERN_PROC_PATHNAME doesn't work here." >&4
+               val="$undef"
+       fi
+else
+       echo "I'm unable to compile the test program." >&4
+       echo "I'll assume no sysctl with KERN_PROC_PATHNAME here." >&4
+       val="$undef"
+fi
+$rm_try
+set usekernprocpathname
+eval $setvar
+
diff --git a/U/perl/usensgetexecutablepath.U b/U/perl/usensgetexecutablepath.U
new file mode 100644 (file)
index 0000000..f3de31e
--- /dev/null
@@ -0,0 +1,116 @@
+?MAKE:usensgetexecutablepath: cat rm_try Compile run Setvar
+?MAKE: -pick add $@ %<
+?S:usensgetexecutablepath:
+?S:    This symbol, if defined, indicates that we can use _NSGetExecutablePath
+?S:    and realpath to get a full path for the executable, and hence convert
+?S:    $^X to an absolute path.
+?S:.
+?C:USE_NSGETEXECUTABLEPATH:
+?C:    This symbol, if defined, indicates that we can use _NSGetExecutablePath
+?C:    and realpath to get a full path for the executable, and hence convert
+?C:    $^X to an absolute path.
+?C:.
+?H:#$usensgetexecutablepath USE_NSGETEXECUTABLEPATH    /**/
+?H:.
+?LINT:set usensgetexecutablepath
+?F:!try
+: Determine if we can use _NSGetExecutablePath to find executing program
+echo " "
+echo "Determining whether we can use _NSGetExecutablePath to find executing program..." >&4
+$cat >try.c <<'EOM'
+/* Intentionally a long probe as I'd like to sanity check that the exact
+   approach is going to work, as thinking it will work, but only having it
+   part working at runtime is worse than not having it.  */
+#include <mach-o/dyld.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/param.h>
+#include <string.h>
+
+int
+main(int argc, char **argv) {
+    char buf[1];
+    uint32_t size = sizeof(buf);
+    int result;
+    char *buffer;
+    char *tidied;
+    char *argv_leaf = strrchr(argv[0], '/');
+    char *tidied_leaf;
+
+    if (!argv_leaf) {
+       fprintf(stderr, "Can't locate / in '%s'\n", argv[0]);
+       return 1;
+    }
+
+    _NSGetExecutablePath(buf, &size);
+    if (size > MAXPATHLEN * MAXPATHLEN) {
+       fprintf(stderr, "_NSGetExecutablePath size %u is too long for a path\n",
+               (unsigned int) size);
+       return 2;
+    }
+
+    buffer = malloc(size);
+    if (!buffer) {
+       perror("malloc");
+       return 3;
+    }
+
+    result = _NSGetExecutablePath(buffer, &size);
+    if (result != 0) {
+       fprintf(stderr, "_NSGetExecutablePath returned %i for a size of %u\n",
+               result, (unsigned int) size);
+       return 4;
+    }
+
+    tidied = realpath(buffer, NULL);
+    if (!tidied) {
+       perror("realpath");
+       return 5;
+    }
+
+    free(buffer);
+
+    if (*tidied != '/') {
+       fprintf(stderr, "Not an absolute path: '%s'\n", tidied);
+       return 6;
+    }
+
+    if (strstr(tidied, "/./")) {
+       fprintf(stderr, "Contains /./: '%s'\n", tidied);
+       return 7;
+    }
+
+    if (strstr(tidied, "/../")) {
+       fprintf(stderr, "Contains /../: '%s'\n", tidied);
+       return 8;
+    }
+
+    tidied_leaf = strrchr(tidied, '/');
+    if (strcmp(tidied_leaf, argv_leaf) != 0) {
+       fprintf(stderr, "Leafnames differ: '%s' vs '%s'\n", argv[0], tidied);
+       return 9;
+    }
+
+    free(tidied);
+
+    return 0;
+}
+EOM
+
+val=$undef
+set try
+if eval $compile_ok; then
+       if $run ./try; then
+               echo "You can use _NSGetExecutablePath to find the executing program." >&4
+               val="$define"
+       else
+               echo "Nope, _NSGetExecutablePath doesn't work here." >&4
+       fi
+else
+       echo "I'm unable to compile the test program." >&4
+       echo "I'll assume no _NSGetExecutablePath here." >&4
+fi
+$rm_try
+set usensgetexecutablepath
+eval $setvar
+