URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [syscall/] [exec_windows.go] - Blame information for rev 747

Details | Compare with Previous | View Log


// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
 
// Fork, exec, wait, etc.
 
package syscall
 
import (
        "sync"
        "unicode/utf16"
        "unsafe"
)
 
var ForkLock sync.RWMutex
 
// EscapeArg rewrites command line argument s as prescribed
// in http://msdn.microsoft.com/en-us/library/ms880421.
// This function returns "" (2 double quotes) if s is empty.
// Alternatively, these transformations are done:
// - every back slash (\) is doubled, but only if immediately
//   followed by double quote (");
// - every double quote (") is escaped by back slash (\);
// - finally, s is wrapped with double quotes (arg -> "arg"),
//   but only if there is space or tab inside s.
func EscapeArg(s string) string {
        if len(s) == 0 {
                return "\"\""
        }
        n := len(s)
        hasSpace := false
        for i := 0; i < len(s); i++ {
                switch s[i] {
                case '"', '\\':
                        n++
                case ' ', '\t':
                        hasSpace = true
                }
        }
        if hasSpace {
                n += 2
        }
        if n == len(s) {
                return s
        }
 
        qs := make([]byte, n)
        j := 0
        if hasSpace {
                qs[j] = '"'
                j++
        }
        slashes := 0
        for i := 0; i < len(s); i++ {
                switch s[i] {
                default:
                        slashes = 0
                        qs[j] = s[i]
                case '\\':
                        slashes++
                        qs[j] = s[i]
                case '"':
                        for ; slashes > 0; slashes-- {
                                qs[j] = '\\'
                                j++
                        }
                        qs[j] = '\\'
                        j++
                        qs[j] = s[i]
                }
                j++
        }
        if hasSpace {
                for ; slashes > 0; slashes-- {
                        qs[j] = '\\'
                        j++
                }
                qs[j] = '"'
                j++
        }
        return string(qs[:j])
}
 
// makeCmdLine builds a command line out of args by escaping "special"
// characters and joining the arguments with spaces.
func makeCmdLine(args []string) string {
        var s string
        for _, v := range args {
                if s != "" {
                        s += " "
                }
                s += EscapeArg(v)
        }
        return s
}
 
// createEnvBlock converts an array of environment strings into
// the representation required by CreateProcess: a sequence of NUL
// terminated strings followed by a nil.
// Last bytes are two UCS-2 NULs, or four NUL bytes.
func createEnvBlock(envv []string) *uint16 {
        if len(envv) == 0 {
                return &utf16.Encode([]rune("\x00\x00"))[0]
        }
        length := 0
        for _, s := range envv {
                length += len(s) + 1
        }
        length += 1
 
        b := make([]byte, length)
        i := 0
        for _, s := range envv {
                l := len(s)
                copy(b[i:i+l], []byte(s))
                copy(b[i+l:i+l+1], []byte{0})
                i = i + l + 1
        }
        copy(b[i:i+1], []byte{0})
 
        return &utf16.Encode([]rune(string(b)))[0]
}
 
func CloseOnExec(fd Handle) {
        SetHandleInformation(Handle(fd), HANDLE_FLAG_INHERIT, 0)
}
 
func SetNonblock(fd Handle, nonblocking bool) (err error) {
        return nil
}
 
// getFullPath retrieves the full path of the specified file.
// Just a wrapper for Windows GetFullPathName api.
func getFullPath(name string) (path string, err error) {
        p := StringToUTF16Ptr(name)
        buf := make([]uint16, 100)
        n, err := GetFullPathName(p, uint32(len(buf)), &buf[0], nil)
        if err != nil {
                return "", err
        }
        if n > uint32(len(buf)) {
                // Windows is asking for bigger buffer.
                buf = make([]uint16, n)
                n, err = GetFullPathName(p, uint32(len(buf)), &buf[0], nil)
                if err != nil {
                        return "", err
                }
                if n > uint32(len(buf)) {
                        return "", EINVAL
                }
        }
        return UTF16ToString(buf[:n]), nil
}
 
func isSlash(c uint8) bool {
        return c == '\\' || c == '/'
}
 
func normalizeDir(dir string) (name string, err error) {
        ndir, err := getFullPath(dir)
        if err != nil {
                return "", err
        }
        if len(ndir) > 2 && isSlash(ndir[0]) && isSlash(ndir[1]) {
                // dir cannot have \\server\share\path form
                return "", EINVAL
        }
        return ndir, nil
}
 
func volToUpper(ch int) int {
        if 'a' <= ch && ch <= 'z' {
                ch += 'A' - 'a'
        }
        return ch
}
 
func joinExeDirAndFName(dir, p string) (name string, err error) {
        if len(p) == 0 {
                return "", EINVAL
        }
        if len(p) > 2 && isSlash(p[0]) && isSlash(p[1]) {
                // \\server\share\path form
                return p, nil
        }
        if len(p) > 1 && p[1] == ':' {
                // has drive letter
                if len(p) == 2 {
                        return "", EINVAL
                }
                if isSlash(p[2]) {
                        return p, nil
                } else {
                        d, err := normalizeDir(dir)
                        if err != nil {
                                return "", err
                        }
                        if volToUpper(int(p[0])) == volToUpper(int(d[0])) {
                                return getFullPath(d + "\\" + p[2:])
                        } else {
                                return getFullPath(p)
                        }
                }
        } else {
                // no drive letter
                d, err := normalizeDir(dir)
                if err != nil {
                        return "", err
                }
                if isSlash(p[0]) {
                        return getFullPath(d[:2] + p)
                } else {
                        return getFullPath(d + "\\" + p)
                }
        }
        // we shouldn't be here
        return "", EINVAL
}
 
type ProcAttr struct {
        Dir   string
        Env   []string
        Files []Handle
        Sys   *SysProcAttr
}
 
type SysProcAttr struct {
        HideWindow bool
        CmdLine    string // used if non-empty, else the windows command line is built by escaping the arguments passed to StartProcess
}
 
var zeroProcAttr ProcAttr
var zeroSysProcAttr SysProcAttr
 
func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle uintptr, err error) {
        if len(argv0) == 0 {
                return 0, 0, EWINDOWS
        }
        if attr == nil {
                attr = &zeroProcAttr
        }
        sys := attr.Sys
        if sys == nil {
                sys = &zeroSysProcAttr
        }
 
        if len(attr.Files) > 3 {
                return 0, 0, EWINDOWS
        }
 
        if len(attr.Dir) != 0 {
                // StartProcess assumes that argv0 is relative to attr.Dir,
                // because it implies Chdir(attr.Dir) before executing argv0.
                // Windows CreateProcess assumes the opposite: it looks for
                // argv0 relative to the current directory, and, only once the new
                // process is started, it does Chdir(attr.Dir). We are adjusting
                // for that difference here by making argv0 absolute.
                var err error
                argv0, err = joinExeDirAndFName(attr.Dir, argv0)
                if err != nil {
                        return 0, 0, err
                }
        }
        argv0p := StringToUTF16Ptr(argv0)
 
        var cmdline string
        // Windows CreateProcess takes the command line as a single string:
        // use attr.CmdLine if set, else build the command line by escaping
        // and joining each argument with spaces
        if sys.CmdLine != "" {
                cmdline = sys.CmdLine
        } else {
                cmdline = makeCmdLine(argv)
        }
 
        var argvp *uint16
        if len(cmdline) != 0 {
                argvp = StringToUTF16Ptr(cmdline)
        }
 
        var dirp *uint16
        if len(attr.Dir) != 0 {
                dirp = StringToUTF16Ptr(attr.Dir)
        }
 
        // Acquire the fork lock so that no other threads
        // create new fds that are not yet close-on-exec
        // before we fork.
        ForkLock.Lock()
        defer ForkLock.Unlock()
 
        p, _ := GetCurrentProcess()
        fd := make([]Handle, len(attr.Files))
        for i := range attr.Files {
                if attr.Files[i] > 0 {
                        err := DuplicateHandle(p, Handle(attr.Files[i]), p, &fd[i], 0, true, DUPLICATE_SAME_ACCESS)
                        if err != nil {
                                return 0, 0, err
                        }
                        defer CloseHandle(Handle(fd[i]))
                }
        }
        si := new(StartupInfo)
        si.Cb = uint32(unsafe.Sizeof(*si))
        si.Flags = STARTF_USESTDHANDLES
        if sys.HideWindow {
                si.Flags |= STARTF_USESHOWWINDOW
                si.ShowWindow = SW_HIDE
        }
        si.StdInput = fd[0]
        si.StdOutput = fd[1]
        si.StdErr = fd[2]
 
        pi := new(ProcessInformation)
 
        err = CreateProcess(argv0p, argvp, nil, nil, true, CREATE_UNICODE_ENVIRONMENT, createEnvBlock(attr.Env), dirp, si, pi)
        if err != nil {
                return 0, 0, err
        }
        defer CloseHandle(Handle(pi.Thread))
 
        return int(pi.ProcessId), uintptr(pi.Process), nil
}
 
func Exec(argv0 string, argv []string, envv []string) (err error) {
        return EWINDOWS
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [syscall/] [exec_windows.go] - Blame information for rev 747

Line No.	Rev	Author	Line
1	747	jeremybenn	`// Copyright 2009 The Go Authors. All rights reserved.`
2			`// Use of this source code is governed by a BSD-style`
3			`// license that can be found in the LICENSE file.`
4
5			`// Fork, exec, wait, etc.`
6
7			`package syscall`
8
9			`import (`
10			`"sync"`
11			`"unicode/utf16"`
12			`"unsafe"`
13			`)`
14
15			`var ForkLock sync.RWMutex`
16
17			`// EscapeArg rewrites command line argument s as prescribed`
18			`// in http://msdn.microsoft.com/en-us/library/ms880421.`
19			`// This function returns "" (2 double quotes) if s is empty.`
20			`// Alternatively, these transformations are done:`
21			`// - every back slash (\) is doubled, but only if immediately`
22			`// followed by double quote (");`
23			`// - every double quote (") is escaped by back slash (\);`
24			`// - finally, s is wrapped with double quotes (arg -> "arg"),`
25			`// but only if there is space or tab inside s.`
26			`func EscapeArg(s string) string {`
27			`if len(s) == 0 {`
28			`return "\"\""`
29			`}`
30			`n := len(s)`
31			`hasSpace := false`
32			`for i := 0; i < len(s); i++ {`
33			`switch s[i] {`
34			`case '"', '\\':`
35			`n++`
36			`case ' ', '\t':`
37			`hasSpace = true`
38			`}`
39			`}`
40			`if hasSpace {`
41			`n += 2`
42			`}`
43			`if n == len(s) {`
44			`return s`
45			`}`
46
47			`qs := make([]byte, n)`
48			`j := 0`
49			`if hasSpace {`
50			`qs[j] = '"'`
51			`j++`
52			`}`
53			`slashes := 0`
54			`for i := 0; i < len(s); i++ {`
55			`switch s[i] {`
56			`default:`
57			`slashes = 0`
58			`qs[j] = s[i]`
59			`case '\\':`
60			`slashes++`
61			`qs[j] = s[i]`
62			`case '"':`
63			`for ; slashes > 0; slashes-- {`
64			`qs[j] = '\\'`
65			`j++`
66			`}`
67			`qs[j] = '\\'`
68			`j++`
69			`qs[j] = s[i]`
70			`}`
71			`j++`
72			`}`
73			`if hasSpace {`
74			`for ; slashes > 0; slashes-- {`
75			`qs[j] = '\\'`
76			`j++`
77			`}`
78			`qs[j] = '"'`
79			`j++`
80			`}`
81			`return string(qs[:j])`
82			`}`
83
84			`// makeCmdLine builds a command line out of args by escaping "special"`
85			`// characters and joining the arguments with spaces.`
86			`func makeCmdLine(args []string) string {`
87			`var s string`
88			`for _, v := range args {`
89			`if s != "" {`
90			`s += " "`
91			`}`
92			`s += EscapeArg(v)`
93			`}`
94			`return s`
95			`}`
96
97			`// createEnvBlock converts an array of environment strings into`
98			`// the representation required by CreateProcess: a sequence of NUL`
99			`// terminated strings followed by a nil.`
100			`// Last bytes are two UCS-2 NULs, or four NUL bytes.`
101			`func createEnvBlock(envv []string) *uint16 {`
102			`if len(envv) == 0 {`
103			`return &utf16.Encode([]rune("\x00\x00"))[0]`
104			`}`
105			`length := 0`
106			`for _, s := range envv {`
107			`length += len(s) + 1`
108			`}`
109			`length += 1`
110
111			`b := make([]byte, length)`
112			`i := 0`
113			`for _, s := range envv {`
114			`l := len(s)`
115			`copy(b[i:i+l], []byte(s))`
116			`copy(b[i+l:i+l+1], []byte{0})`
117			`i = i + l + 1`
118			`}`
119			`copy(b[i:i+1], []byte{0})`
120
121			`return &utf16.Encode([]rune(string(b)))[0]`
122			`}`
123
124			`func CloseOnExec(fd Handle) {`
125			`SetHandleInformation(Handle(fd), HANDLE_FLAG_INHERIT, 0)`
126			`}`
127
128			`func SetNonblock(fd Handle, nonblocking bool) (err error) {`
129			`return nil`
130			`}`
131
132			`// getFullPath retrieves the full path of the specified file.`
133			`// Just a wrapper for Windows GetFullPathName api.`
134			`func getFullPath(name string) (path string, err error) {`
135			`p := StringToUTF16Ptr(name)`
136			`buf := make([]uint16, 100)`
137			`n, err := GetFullPathName(p, uint32(len(buf)), &buf[0], nil)`
138			`if err != nil {`
139			`return "", err`
140			`}`
141			`if n > uint32(len(buf)) {`
142			`// Windows is asking for bigger buffer.`
143			`buf = make([]uint16, n)`
144			`n, err = GetFullPathName(p, uint32(len(buf)), &buf[0], nil)`
145			`if err != nil {`
146			`return "", err`
147			`}`
148			`if n > uint32(len(buf)) {`
149			`return "", EINVAL`
150			`}`
151			`}`
152			`return UTF16ToString(buf[:n]), nil`
153			`}`
154
155			`func isSlash(c uint8) bool {`
156			`return c == '\\' \|\| c == '/'`
157			`}`
158
159			`func normalizeDir(dir string) (name string, err error) {`
160			`ndir, err := getFullPath(dir)`
161			`if err != nil {`
162			`return "", err`
163			`}`
164			`if len(ndir) > 2 && isSlash(ndir[0]) && isSlash(ndir[1]) {`
165			`// dir cannot have \\server\share\path form`
166			`return "", EINVAL`
167			`}`
168			`return ndir, nil`
169			`}`
170
171			`func volToUpper(ch int) int {`
172			`if 'a' <= ch && ch <= 'z' {`
173			`ch += 'A' - 'a'`
174			`}`
175			`return ch`
176			`}`
177
178			`func joinExeDirAndFName(dir, p string) (name string, err error) {`
179			`if len(p) == 0 {`
180			`return "", EINVAL`
181			`}`
182			`if len(p) > 2 && isSlash(p[0]) && isSlash(p[1]) {`
183			`// \\server\share\path form`
184			`return p, nil`
185			`}`
186			`if len(p) > 1 && p[1] == ':' {`
187			`// has drive letter`
188			`if len(p) == 2 {`
189			`return "", EINVAL`
190			`}`
191			`if isSlash(p[2]) {`
192			`return p, nil`
193			`} else {`
194			`d, err := normalizeDir(dir)`
195			`if err != nil {`
196			`return "", err`
197			`}`
198			`if volToUpper(int(p[0])) == volToUpper(int(d[0])) {`
199			`return getFullPath(d + "\\" + p[2:])`
200			`} else {`
201			`return getFullPath(p)`
202			`}`
203			`}`
204			`} else {`
205			`// no drive letter`
206			`d, err := normalizeDir(dir)`
207			`if err != nil {`
208			`return "", err`
209			`}`
210			`if isSlash(p[0]) {`
211			`return getFullPath(d[:2] + p)`
212			`} else {`
213			`return getFullPath(d + "\\" + p)`
214			`}`
215			`}`
216			`// we shouldn't be here`
217			`return "", EINVAL`
218			`}`
219
220			`type ProcAttr struct {`
221			`Dir string`
222			`Env []string`
223			`Files []Handle`
224			`Sys *SysProcAttr`
225			`}`
226
227			`type SysProcAttr struct {`
228			`HideWindow bool`
229			`CmdLine string // used if non-empty, else the windows command line is built by escaping the arguments passed to StartProcess`
230			`}`
231
232			`var zeroProcAttr ProcAttr`
233			`var zeroSysProcAttr SysProcAttr`
234
235			`func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle uintptr, err error) {`
236			`if len(argv0) == 0 {`
237			`return 0, 0, EWINDOWS`
238			`}`
239			`if attr == nil {`
240			`attr = &zeroProcAttr`
241			`}`
242			`sys := attr.Sys`
243			`if sys == nil {`
244			`sys = &zeroSysProcAttr`
245			`}`
246
247			`if len(attr.Files) > 3 {`
248			`return 0, 0, EWINDOWS`
249			`}`
250
251			`if len(attr.Dir) != 0 {`
252			`// StartProcess assumes that argv0 is relative to attr.Dir,`
253			`// because it implies Chdir(attr.Dir) before executing argv0.`
254			`// Windows CreateProcess assumes the opposite: it looks for`
255			`// argv0 relative to the current directory, and, only once the new`
256			`// process is started, it does Chdir(attr.Dir). We are adjusting`
257			`// for that difference here by making argv0 absolute.`
258			`var err error`
259			`argv0, err = joinExeDirAndFName(attr.Dir, argv0)`
260			`if err != nil {`
261			`return 0, 0, err`
262			`}`
263			`}`
264			`argv0p := StringToUTF16Ptr(argv0)`
265
266			`var cmdline string`
267			`// Windows CreateProcess takes the command line as a single string:`
268			`// use attr.CmdLine if set, else build the command line by escaping`
269			`// and joining each argument with spaces`
270			`if sys.CmdLine != "" {`
271			`cmdline = sys.CmdLine`
272			`} else {`
273			`cmdline = makeCmdLine(argv)`
274			`}`
275
276			`var argvp *uint16`
277			`if len(cmdline) != 0 {`
278			`argvp = StringToUTF16Ptr(cmdline)`
279			`}`
280
281			`var dirp *uint16`
282			`if len(attr.Dir) != 0 {`
283			`dirp = StringToUTF16Ptr(attr.Dir)`
284			`}`
285
286			`// Acquire the fork lock so that no other threads`
287			`// create new fds that are not yet close-on-exec`
288			`// before we fork.`
289			`ForkLock.Lock()`
290			`defer ForkLock.Unlock()`
291
292			`p, _ := GetCurrentProcess()`
293			`fd := make([]Handle, len(attr.Files))`
294			`for i := range attr.Files {`
295			`if attr.Files[i] > 0 {`
296			`err := DuplicateHandle(p, Handle(attr.Files[i]), p, &fd[i], 0, true, DUPLICATE_SAME_ACCESS)`
297			`if err != nil {`
298			`return 0, 0, err`
299			`}`
300			`defer CloseHandle(Handle(fd[i]))`
301			`}`
302			`}`
303			`si := new(StartupInfo)`
304			`si.Cb = uint32(unsafe.Sizeof(*si))`
305			`si.Flags = STARTF_USESTDHANDLES`
306			`if sys.HideWindow {`
307			`si.Flags \|= STARTF_USESHOWWINDOW`
308			`si.ShowWindow = SW_HIDE`
309			`}`
310			`si.StdInput = fd[0]`
311			`si.StdOutput = fd[1]`
312			`si.StdErr = fd[2]`
313
314			`pi := new(ProcessInformation)`
315
316			`err = CreateProcess(argv0p, argvp, nil, nil, true, CREATE_UNICODE_ENVIRONMENT, createEnvBlock(attr.Env), dirp, si, pi)`
317			`if err != nil {`
318			`return 0, 0, err`
319			`}`
320			`defer CloseHandle(Handle(pi.Thread))`
321
322			`return int(pi.ProcessId), uintptr(pi.Process), nil`
323			`}`
324
325			`func Exec(argv0 string, argv []string, envv []string) (err error) {`
326			`return EWINDOWS`
327			`}`