Subversion Repositories openrisc

// Copyright 2011 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.

// Plan 9 environment variables.

package syscall

import (

        "errors"

        "sync"

)

var (

        // envOnce guards initialization by copyenv, which populates env.

        envOnce sync.Once

        // envLock guards env.

        envLock sync.RWMutex

        // env maps from an environment variable to its value.

        env map[string]string

)

func readenv(key string) (string, error) {

        fd, err := Open("/env/"+key, O_RDONLY)

        if err != nil {

                return "", err

        }

        defer Close(fd)

        l, _ := Seek(fd, 0, 2)

        Seek(fd, 0, 0)

        buf := make([]byte, l)

        n, err := Read(fd, buf)

        if err != nil {

                return "", err

        }

        if n > 0 && buf[n-1] == 0 {

                buf = buf[:n-1]

        }

        return string(buf), nil

}

func writeenv(key, value string) error {

        fd, err := Create("/env/"+key, O_RDWR, 0666)

        if err != nil {

                return err

        }

        defer Close(fd)

        _, err = Write(fd, []byte(value))

        return err

}

func copyenv() {

        env = make(map[string]string)

        fd, err := Open("/env", O_RDONLY)

        if err != nil {

                return

        }

        defer Close(fd)

        files, err := readdirnames(fd)

        if err != nil {

                return

        }

        for _, key := range files {

                v, err := readenv(key)

                if err != nil {

                        continue

                }

                env[key] = v

        }

}

func Getenv(key string) (value string, found bool) {

        envOnce.Do(copyenv)

        if len(key) == 0 {

                return "", false

        }

        envLock.RLock()

        defer envLock.RUnlock()

        v, ok := env[key]

        if !ok {

                return "", false

        }

        return v, true

}

func Setenv(key, value string) error {

        envOnce.Do(copyenv)

        if len(key) == 0 {

                return errors.New("zero length key")

        }

        envLock.Lock()

        defer envLock.Unlock()

        err := writeenv(key, value)

        if err != nil {

                return err

        }

        env[key] = value

        return nil

}

func Clearenv() {

        envOnce.Do(copyenv) // prevent copyenv in Getenv/Setenv

        envLock.Lock()

        defer envLock.Unlock()

        env = make(map[string]string)

        RawSyscall(SYS_RFORK, RFCENVG, 0, 0)

}

func Environ() []string {

        envOnce.Do(copyenv)

        envLock.RLock()

        defer envLock.RUnlock()

        a := make([]string, len(env))

        i := 0

        for k, v := range env {

                a[i] = k + "=" + v

                i++

        }

        return a

}