os/exec: document that LookPath result may only be valid relative to current directory

[alexbrainman]

This program should work, but fails

package main

import (
    "fmt"
    "log"
    "os"
    "os/exec"
    "path/filepath"
    "runtime"
)

func main() {
    var prog string
    if runtime.GOOS != "windows" {
        prog = "date"
        // add . at the front of our PATH,
        // windows starts search in the current directory anyway
        p := os.Getenv("PATH")
        err := os.Setenv("PATH", ".:"+p)
        if err != nil {
            log.Fatal(err)
        }
    } else {
        prog = "ipconfig"
    }
    // find our executable
    path, err := exec.LookPath(prog)
    if err != nil {
        log.Fatal(err)
    }
    dir, _ := filepath.Split(path)
    // chdir to where our executable lives
    err = os.Chdir(dir)
    if err != nil {
        log.Fatal(err)
    }
    // find our executable again
    path, err = exec.LookPath(prog)
    if err != nil {
        log.Fatal(err)
    }
    // run our executable with /tmp directory as current
    cmd := exec.Command(path)
    cmd.Dir = os.TempDir()
    out, err := cmd.CombinedOutput()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("out=%v\n", string(out))
}

I am not sure where things should be changed.

Alex

[bradfitz]

Comment 2:

Your summary says "relative path returned by LookPath".
The whole point of LookPath is to return an absolute path.

[alexbrainman]

Comment 3:

Well, it is returning relative path in some situations (see my sample program). If that
is incorrect, lets change it.
Alex

[rsc]

Comment 4:

it can return a relative path when . is in your path, i think

[alexbrainman]

Comment 5:

That is, in fact, default on Windows. Windows always look in the current directory first.
Alex

[rsc]

Comment 6:

I think LookPath returning a relative path is okay. The fix here is that if you're going
to do a Chdir and prog is a relative path, make it an absolute path before the Chdir.
But that is a fix in func main. I don't know whether there's anything in the tree to fix
but docs.

[rsc]

Comment 7:

Labels changed: added priority-later, removed priority-triage.

[rsc]

Comment 8:

Labels changed: added go1.1maybe.

[alexbrainman]

Comment 9:

@rsc,
>>> ... The fix here is that if you're going to do a Chdir and prog is a relative path,
make it an absolute path before the Chdir ...
I am slow, so, please, send amended program and I will try it. Thank you.
Alex

[rsc]

Comment 10:

The fixed program would go something like
    // find our executable
    path, err := exec.LookPath(prog)
    if err != nil {
        log.Fatal(err)
    }
    // get absolute path so we can run it from /tmp
        path, err = filepath.Abs(path)
        if err != nil {
                log.Fatal(err)
        }
    // run our executable with /tmp directory as current
    cmd := exec.Command(path)
    cmd.Dir = os.TempDir()
    out, err := cmd.CombinedOutput()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("out=%v\n", string(out))

[alexbrainman]

Comment 11:

I see. Are you saying that result of successful exec.LookPath is not always ready for
consumption by exec.Command? Then we need to document that and also, probably, be able
to explain why it is so. :-(
Alex

[rsc]

Comment 12:

relative to current directory

[rsc]

Comment 14:

Labels changed: added size-m.

[rsc]

Comment 15:

[The time for maybe has passed.]

Labels changed: removed go1.1maybe.

[rsc]

Comment 16:

Labels changed: added go1.2.

[robpike]

Comment 17:

This issue was closed by revision a41a5bb.

Status changed to Fixed.