exec.Cmd does inserts a lot of back slashes (and other characters) when it builds command line on windows. See https://github.com/golang/go/blob/master/src/syscall/exec_windows.go#L84 for details. But I don't think these back slashes are random. That is what Microsoft recomends we do (see a link in the code).

I think your case fails because exec.Cmd tries hard to incorporate " into paths and other parameters, and 7za is confused by these. I think you're trying too hard, tyr this (not tested):

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    zippath := "C:\\test.zip"
    outputpath := "C:\\testfolder\\"

    cmd := exec.Command("7za", "x", zippath, "-aoa", "-r", "-o"+outputpath, "*.xml")
    fmt.Printf("cmd.Args: %q\n", cmd.Args)

    cmdoutput, err := cmd.CombinedOutput()
    fmt.Println("output:", string(cmdoutput), err)
}

Alex

That works, fortunately 7-Zip supports "-oC:\Path with spaces\", otherwise this would be impossible to do if a program didn't support it but only supported -o"...". Another workaround would be using Batch or Bash files but that's dependent on the operating system.

... fortunately 7-Zip supports "-oC:\Path with spaces", otherwise this would be impossible to do if a program didn't support it but only supported -o"...".

I don't understand. Are you saying that my suggestion above will not work if output path contains space? But I think it will just work too.

Try this

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    zippath := "C:\\test.zip"
    outputpath := "C:\\Path with spaces\\"

    cmd := exec.Command("7za", "x", zippath, "-aoa", "-r", "-o"+outputpath, "*.xml")
    fmt.Printf("cmd.Args: %q\n", cmd.Args)

    cmdoutput, err := cmd.CombinedOutput()
    fmt.Println("output:", string(cmdoutput), err)
}

Alex

Your example works fine, I'm talking about a program that does not support "-o..." but only supports -o"..."

I'm talking about a program that does not support "-o..." but only supports -o"..."

I still don't understand what you're after. But, perhaps, that is not important. Should we close this issue as "exec.Command is working as intended"?

Alex

Let's assume there is a program that accepts a parameter -o, it only accepts this parameter if -o is in this format:

someprogram -o"………"

It does not accept:

someprogram "-o………"

So someprogram user can't do this in shell: someprogram "-oC:\Folder with space\"
But can do this: someprogram -o"C:\Folder with space\"

_This is how this program behaves, it is coded this way_, it does not allow quotes dash o path quotes because the programmer doesn't use a good parsing method. Programmer coded their program so only it accepts values if parameter meets this format: dash o quotes path quotes

Windows doesn't have any problem and executes this command someprogram -o"C:\Folder with space\ without any errors. When you execute the exact command in Go, it escapes things inaccurately and adds \ in front of C:\Folder with space\ thus command fails.

someprogram has to use -o"..." format to work, because someprogram -o"C:\Folder with space\" works in Command Prompt, it should work in Go too:

cmd := exec.Command("someprogram", `-o"C:\Folder with space\"`)
cmd.Run() // doesn't work, path becomes \C:\Folder with space\, program fails

Thank you for explaining. Unfortunately everything you say is just you guessing about how system works. Why don't you provide a real example of a problem?

Alex

You can't use fmt.Sprintf followed by strings.Fields and pass the space-separated split to exec.Command and expect it to work when you have arguments containing spaces. That's just very broken, since that doesn't match how your shell (cmd.exe) is splitting your arguments.

Let's move this to the mailing list since this isn't a bug as far as I can see.

Since we are talking about cmd.exe, http://blogs.msdn.com/b/twistylittlepassagesallalike/archive/2011/04/23/everyone-quotes-arguments-the-wrong-way.aspx explains how you pass parameters to it. Not for fainthearted.

Alex

@bradfitz if you look at my last example in my first comment, I'm not using any functions:

cmd := exec.Command("7za", "x", "C:\\test.zip", "-aoa", "-r", `-o"C:\testfolder\"`, "*.xml")
fmt.Println("cmd.Args:", cmd.Args)

cmdoutput, err := cmd.CombinedOutput()
fmt.Println("output:", string(cmdoutput), err)

This works in Command Prompt and fails in Go.

This works in Command Prompt and fails in Go.

The way you escape characters in "Command Prompt" and Go are different. For "Command Prompt" escape rules see my URL above. For Go you don't need to escape anything (except standard Go escape rules for strings), you pass your arguments to exec.Command exactly how you want your child process see them.

Alex

@dogancelik, yes, what @alexbrainman said. I doubt you want the 7za program to see double quote marks on that -o.... parameter. Does 7a do its own shell unquoting? I kinda doubt it.