← Back to branch summary

~ubuntu-branches/ubuntu/utopic/golang/utopic

« back to all changes in this revision

Viewing changes to src/pkg/syscall/env_plan9.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-20 14:06:23 UTC
  • mfrom: (14.1.23 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130820140623-b414jfxi3m0qkmrq
Tags: 2:1.1.2-2ubuntu1
https://launchpad.net/bugs/1211749
https://launchpad.net/bugs/1202027
* Merge from Debian unstable (LP: #1211749, #1202027). Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - d/control,control.cross: Update Breaks/Replaces for Ubuntu
    versions to ensure smooth upgrades, regenerate control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/syscall/env_plan9.go
12
12
)
13
13
 
14
14
var (
15
 
        // envOnce guards initialization by copyenv, which populates env.
 
15
        // envOnce guards copyenv, which populates env.
16
16
        envOnce sync.Once
17
17
 
18
 
        // envLock guards env.
 
18
        // envLock guards env and envs.
19
19
        envLock sync.RWMutex
20
20
 
21
21
        // env maps from an environment variable to its value.
22
 
        env map[string]string
 
22
        env = make(map[string]string)
 
23
 
 
24
        // envs contains elements of env in the form "key=value".
 
25
        envs []string
 
26
 
 
27
        errZeroLengthKey = errors.New("zero length key")
 
28
        errShortWrite    = errors.New("i/o count too small")
23
29
)
24
30
 
25
31
func readenv(key string) (string, error) {
47
53
                return err
48
54
        }
49
55
        defer Close(fd)
50
 
        _, err = Write(fd, []byte(value))
51
 
        return err
 
56
        b := []byte(value)
 
57
        n, err := Write(fd, b)
 
58
        if err != nil {
 
59
                return err
 
60
        }
 
61
        if n != len(b) {
 
62
                return errShortWrite
 
63
        }
 
64
        return nil
52
65
}
53
66
 
54
67
func copyenv() {
55
 
        env = make(map[string]string)
56
68
        fd, err := Open("/env", O_RDONLY)
57
69
        if err != nil {
58
70
                return
62
74
        if err != nil {
63
75
                return
64
76
        }
 
77
        envs = make([]string, len(files))
 
78
        i := 0
65
79
        for _, key := range files {
66
80
                v, err := readenv(key)
67
81
                if err != nil {
68
82
                        continue
69
83
                }
70
84
                env[key] = v
 
85
                envs[i] = key + "=" + v
 
86
                i++
71
87
        }
72
88
}
73
89
 
74
90
func Getenv(key string) (value string, found bool) {
75
 
        envOnce.Do(copyenv)
76
91
        if len(key) == 0 {
77
92
                return "", false
78
93
        }
80
95
        envLock.RLock()
81
96
        defer envLock.RUnlock()
82
97
 
83
 
        v, ok := env[key]
84
 
        if !ok {
 
98
        if v, ok := env[key]; ok {
 
99
                return v, true
 
100
        }
 
101
        v, err := readenv(key)
 
102
        if err != nil {
85
103
                return "", false
86
104
        }
 
105
        env[key] = v
 
106
        envs = append(envs, key+"="+v)
87
107
        return v, true
88
108
}
89
109
 
90
110
func Setenv(key, value string) error {
91
 
        envOnce.Do(copyenv)
92
111
        if len(key) == 0 {
93
 
                return errors.New("zero length key")
 
112
                return errZeroLengthKey
94
113
        }
95
114
 
96
115
        envLock.Lock()
101
120
                return err
102
121
        }
103
122
        env[key] = value
 
123
        envs = append(envs, key+"="+value)
104
124
        return nil
105
125
}
106
126
 
107
127
func Clearenv() {
108
 
        envOnce.Do(copyenv) // prevent copyenv in Getenv/Setenv
109
 
 
110
128
        envLock.Lock()
111
129
        defer envLock.Unlock()
112
130
 
113
131
        env = make(map[string]string)
 
132
        envs = []string{}
114
133
        RawSyscall(SYS_RFORK, RFCENVG, 0, 0)
115
134
}
116
135
 
117
136
func Environ() []string {
118
 
        envOnce.Do(copyenv)
119
137
        envLock.RLock()
120
138
        defer envLock.RUnlock()
121
 
        a := make([]string, len(env))
122
 
        i := 0
123
 
        for k, v := range env {
124
 
                a[i] = k + "=" + v
125
 
                i++
126
 
        }
127
 
        return a
 
139
 
 
140
        envOnce.Do(copyenv)
 
141
        return append([]string(nil), envs...)
128
142
}