go.sys/unix: delete nacl

It's a peculiar environment that probably doesn't belong here.
We can bring it back easily if we need it.

LGTM=dave, rsc
R=rsc, dave
CC=golang-codereviews
https://golang.org/cl/128110043

unix/asm_nacl_386.s

@@ -1,43 +0,0 @@
-// Copyright 2013 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.
-
-#include "textflag.h"
-#include "../runtime/syscall_nacl.h" // TODO: how to refer to this?
-
-//
-// System call support for 386, Native Client
-//
-
-#define NACL_SYSCALL(code) \
-	MOVL $(0x10000 + ((code)<<5)), AX; CALL AX
-
-#define NACL_SYSJMP(code) \
-	MOVL $(0x10000 + ((code)<<5)), AX; JMP AX
-
-TEXT unix·Syscall(SB),NOSPLIT,$12-28
-	CALL	runtime·entersyscall(SB)
-	MOVL	trap+0(FP), AX
-	MOVL	a1+4(FP), BX
-	MOVL	BX, 0(SP)
-	MOVL	a2+8(FP), BX
-	MOVL	BX, 4(SP)
-	MOVL	a3+12(FP), BX
-	MOVL	BX, 8(SP)
-	SHLL	$5, AX
-	ADDL	$0x10000, AX
-	CALL	AX
-	CMPL	AX, $0
-	JGE	ok
-	MOVL	$-1, r1+16(FP)
-	MOVL	$-1, r2+20(FP)
-	NEGL	AX
-	MOVL	AX, err+24(FP)
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok:
-	MOVL	AX, r1+16(FP)
-	MOVL	DX, r2+20(FP)
-	MOVL	$0, err+24(FP)
-	CALL	runtime·exitsyscall(SB)
-	RET	

unix/asm_nacl_amd64p32.s

@@ -1,41 +0,0 @@
-// Copyright 2013 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.
-
-#include "textflag.h"
-#include "../runtime/syscall_nacl.h" // TODO: how to refer to this?
-
-//
-// System call support for amd64, Native Client
-//
-
-#define NACL_SYSCALL(code) \
-	MOVL $(0x10000 + ((code)<<5)), AX; CALL AX
-
-#define NACL_SYSJMP(code) \
-	MOVL $(0x10000 + ((code)<<5)), AX; JMP AX
-
-TEXT unix·Syscall(SB),NOSPLIT,$0-28
-	CALL	runtime·entersyscall(SB)
-	MOVL	trap+0(FP), AX
-	MOVL	a1+4(FP), DI
-	MOVL	a2+8(FP), SI
-	MOVL	a3+12(FP), DX
-	// more args would use CX, R8, R9
-	SHLL	$5, AX
-	ADDL	$0x10000, AX
-	CALL	AX
-	CMPL	AX, $0
-	JGE	ok
-	MOVL	$-1, r1+16(FP)
-	MOVL	$-1, r2+20(FP)
-	NEGL	AX
-	MOVL	AX, err+24(FP)
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok:
-	MOVL	AX, r1+16(FP)
-	MOVL	DX, r2+20(FP)
-	MOVL	$0, err+24(FP)
-	CALL	runtime·exitsyscall(SB)
-	RET	

unix/asm_nacl_arm.s

@@ -1,43 +0,0 @@
-// Copyright 2014 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.
-
-#include "textflag.h"
-#include "../runtime/syscall_nacl.h" // TODO: how to refer to this?
-
-//
-// System call support for ARM, Native Client
-//
-
-#define NACL_SYSCALL(code) \
-	MOVW $(0x10000 + ((code)<<5)), R8; BL (R8)
-
-#define NACL_SYSJMP(code) \
-	MOVW $(0x10000 + ((code)<<5)), R8; B (R8)
-
-TEXT unix·Syscall(SB),NOSPLIT,$0-28
-	BL	runtime·entersyscall(SB)
-	MOVW	trap+0(FP), R8
-	MOVW	a1+4(FP), R0
-	MOVW	a2+8(FP), R1
-	MOVW	a3+12(FP), R2
-	// more args would use R3, and then stack.
-	MOVW	$0x10000, R7
-	ADD	R8<<5, R7
-	BL	(R7)
-	CMP	$0, R0
-	BGE	ok
-	MOVW	$-1, R1
-	MOVW	R1, r1+16(FP)
-	MOVW	R1, r2+20(FP)
-	RSB	$0, R0
-	MOVW	R0, err+24(FP)
-	BL	runtime·exitsyscall(SB)
-	RET
-ok:
-	MOVW	R0, r1+16(FP)
-	MOVW	R1, r2+20(FP)
-	MOVW	$0, R2
-	MOVW	R2, err+24(FP)
-	BL	runtime·exitsyscall(SB)
-	RET	

unix/env_unix.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris
+// +build darwin dragonfly freebsd linux netbsd openbsd solaris
 
 // Unix environment variables.
 

unix/fd_nacl.go

@@ -1,326 +0,0 @@
-// Copyright 2013 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.
-
-// File descriptor support for Native Client.
-// We want to provide access to a broader range of (simulated) files than
-// Native Client allows, so we maintain our own file descriptor table exposed
-// to higher-level packages.
-
-package unix
-
-import (
-	"sync"
-)
-
-// files is the table indexed by a file descriptor.
-var files struct {
-	sync.RWMutex
-	tab []*file
-}
-
-// A file is an open file, something with a file descriptor.
-// A particular *file may appear in files multiple times, due to use of Dup or Dup2.
-type file struct {
-	fdref int      // uses in files.tab
-	impl  fileImpl // underlying implementation
-}
-
-// A fileImpl is the implementation of something that can be a file.
-type fileImpl interface {
-	// Standard operations.
-	// These can be called concurrently from multiple goroutines.
-	stat(*Stat_t) error
-	read([]byte) (int, error)
-	write([]byte) (int, error)
-	seek(int64, int) (int64, error)
-	pread([]byte, int64) (int, error)
-	pwrite([]byte, int64) (int, error)
-
-	// Close is called when the last reference to a *file is removed
-	// from the file descriptor table. It may be called concurrently
-	// with active operations such as blocked read or write calls.
-	close() error
-}
-
-// newFD adds impl to the file descriptor table,
-// returning the new file descriptor.
-// Like Unix, it uses the lowest available descriptor.
-func newFD(impl fileImpl) int {
-	files.Lock()
-	defer files.Unlock()
-	f := &file{impl: impl, fdref: 1}
-	for fd, oldf := range files.tab {
-		if oldf == nil {
-			files.tab[fd] = f
-			return fd
-		}
-	}
-	fd := len(files.tab)
-	files.tab = append(files.tab, f)
-	return fd
-}
-
-// Install Native Client stdin, stdout, stderr.
-func init() {
-	newFD(&naclFile{naclFD: 0})
-	newFD(&naclFile{naclFD: 1})
-	newFD(&naclFile{naclFD: 2})
-}
-
-// fdToFile retrieves the *file corresponding to a file descriptor.
-func fdToFile(fd int) (*file, error) {
-	files.Lock()
-	defer files.Unlock()
-	if fd < 0 || fd >= len(files.tab) || files.tab[fd] == nil {
-		return nil, EBADF
-	}
-	return files.tab[fd], nil
-}
-
-func Close(fd int) error {
-	files.Lock()
-	if fd < 0 || fd >= len(files.tab) || files.tab[fd] == nil {
-		files.Unlock()
-		return EBADF
-	}
-	f := files.tab[fd]
-	files.tab[fd] = nil
-	f.fdref--
-	fdref := f.fdref
-	files.Unlock()
-	if fdref > 0 {
-		return nil
-	}
-	return f.impl.close()
-}
-
-func CloseOnExec(fd int) {
-	// nothing to do - no exec
-}
-
-func Dup(fd int) (int, error) {
-	files.Lock()
-	defer files.Unlock()
-	if fd < 0 || fd >= len(files.tab) || files.tab[fd] == nil {
-		return -1, EBADF
-	}
-	f := files.tab[fd]
-	f.fdref++
-	for newfd, oldf := range files.tab {
-		if oldf == nil {
-			files.tab[newfd] = f
-			return newfd, nil
-		}
-	}
-	newfd := len(files.tab)
-	files.tab = append(files.tab, f)
-	return newfd, nil
-}
-
-func Dup2(fd, newfd int) error {
-	files.Lock()
-	defer files.Unlock()
-	if fd < 0 || fd >= len(files.tab) || files.tab[fd] == nil || newfd < 0 || newfd >= len(files.tab)+100 {
-		files.Unlock()
-		return EBADF
-	}
-	f := files.tab[fd]
-	f.fdref++
-	for cap(files.tab) <= newfd {
-		files.tab = append(files.tab[:cap(files.tab)], nil)
-	}
-	oldf := files.tab[newfd]
-	var oldfdref int
-	if oldf != nil {
-		oldf.fdref--
-		oldfdref = oldf.fdref
-	}
-	files.tab[newfd] = f
-	files.Unlock()
-	if oldf != nil {
-		if oldfdref == 0 {
-			oldf.impl.close()
-		}
-	}
-	return nil
-}
-
-func Fstat(fd int, st *Stat_t) error {
-	f, err := fdToFile(fd)
-	if err != nil {
-		return err
-	}
-	return f.impl.stat(st)
-}
-
-func Read(fd int, b []byte) (int, error) {
-	f, err := fdToFile(fd)
-	if err != nil {
-		return 0, err
-	}
-	return f.impl.read(b)
-}
-
-var zerobuf [0]byte
-
-func Write(fd int, b []byte) (int, error) {
-	if b == nil {
-		// avoid nil in syscalls; nacl doesn't like that.
-		b = zerobuf[:]
-	}
-	f, err := fdToFile(fd)
-	if err != nil {
-		return 0, err
-	}
-	return f.impl.write(b)
-}
-
-func Pread(fd int, b []byte, offset int64) (int, error) {
-	f, err := fdToFile(fd)
-	if err != nil {
-		return 0, err
-	}
-	return f.impl.pread(b, offset)
-}
-
-func Pwrite(fd int, b []byte, offset int64) (int, error) {
-	f, err := fdToFile(fd)
-	if err != nil {
-		return 0, err
-	}
-	return f.impl.pwrite(b, offset)
-}
-
-func Seek(fd int, offset int64, whence int) (int64, error) {
-	f, err := fdToFile(fd)
-	if err != nil {
-		return 0, err
-	}
-	return f.impl.seek(offset, whence)
-}
-
-// defaulFileImpl implements fileImpl.
-// It can be embedded to complete a partial fileImpl implementation.
-type defaultFileImpl struct{}
-
-func (*defaultFileImpl) close() error                      { return nil }
-func (*defaultFileImpl) stat(*Stat_t) error                { return ENOSYS }
-func (*defaultFileImpl) read([]byte) (int, error)          { return 0, ENOSYS }
-func (*defaultFileImpl) write([]byte) (int, error)         { return 0, ENOSYS }
-func (*defaultFileImpl) seek(int64, int) (int64, error)    { return 0, ENOSYS }
-func (*defaultFileImpl) pread([]byte, int64) (int, error)  { return 0, ENOSYS }
-func (*defaultFileImpl) pwrite([]byte, int64) (int, error) { return 0, ENOSYS }
-
-// naclFile is the fileImpl implementation for a Native Client file descriptor.
-type naclFile struct {
-	defaultFileImpl
-	naclFD int
-}
-
-func (f *naclFile) stat(st *Stat_t) error {
-	return naclFstat(f.naclFD, st)
-}
-
-func (f *naclFile) read(b []byte) (int, error) {
-	n, err := naclRead(f.naclFD, b)
-	if err != nil {
-		n = 0
-	}
-	return n, err
-}
-
-// implemented in package runtime, to add time header on playground
-func naclWrite(fd int, b []byte) int
-
-func (f *naclFile) write(b []byte) (int, error) {
-	n := naclWrite(f.naclFD, b)
-	if n < 0 {
-		return 0, Errno(-n)
-	}
-	return n, nil
-}
-
-func (f *naclFile) seek(off int64, whence int) (int64, error) {
-	old := off
-	err := naclSeek(f.naclFD, &off, whence)
-	if err != nil {
-		return old, err
-	}
-	return off, nil
-}
-
-func (f *naclFile) prw(b []byte, offset int64, rw func([]byte) (int, error)) (int, error) {
-	// NaCl has no pread; simulate with seek and hope for no races.
-	old, err := f.seek(0, 1)
-	if err != nil {
-		return 0, err
-	}
-	if _, err := f.seek(offset, 0); err != nil {
-		return 0, err
-	}
-	n, err := rw(b)
-	f.seek(old, 0)
-	return n, err
-}
-
-func (f *naclFile) pread(b []byte, offset int64) (int, error) {
-	return f.prw(b, offset, f.read)
-}
-
-func (f *naclFile) pwrite(b []byte, offset int64) (int, error) {
-	return f.prw(b, offset, f.write)
-}
-
-func (f *naclFile) close() error {
-	err := naclClose(f.naclFD)
-	f.naclFD = -1
-	return err
-}
-
-// A pipeFile is an in-memory implementation of a pipe.
-// The byteq implementation is in net_nacl.go.
-type pipeFile struct {
-	defaultFileImpl
-	rd *byteq
-	wr *byteq
-}
-
-func (f *pipeFile) close() error {
-	if f.rd != nil {
-		f.rd.close()
-	}
-	if f.wr != nil {
-		f.wr.close()
-	}
-	return nil
-}
-
-func (f *pipeFile) read(b []byte) (int, error) {
-	if f.rd == nil {
-		return 0, EINVAL
-	}
-	n, err := f.rd.read(b, 0)
-	if err == EAGAIN {
-		err = nil
-	}
-	return n, err
-}
-
-func (f *pipeFile) write(b []byte) (int, error) {
-	if f.wr == nil {
-		return 0, EINVAL
-	}
-	n, err := f.wr.write(b, 0)
-	if err == EAGAIN {
-		err = EPIPE
-	}
-	return n, err
-}
-
-func Pipe(fd []int) error {
-	q := newByteq()
-	fd[0] = newFD(&pipeFile{rd: q})
-	fd[1] = newFD(&pipeFile{wr: q})
-	return nil
-}

unix/fs_nacl.go

@@ -1,832 +0,0 @@
-// Copyright 2013 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.
-
-// A simulated Unix-like file system for use within NaCl.
-//
-// The simulation is not particularly tied to NaCl other than the reuse
-// of NaCl's definition for the Stat_t structure.
-//
-// The file system need never be written to disk, so it is represented as
-// in-memory Go data structures, never in a serialized form.
-//
-// TODO: Perhaps support symlinks, although they muck everything up.
-
-package unix
-
-import (
-	"sync"
-	"unsafe"
-)
-
-// Provided by package runtime.
-func now() (sec int64, nsec int32)
-
-// An fsys is a file system.
-// Since there is no I/O (everything is in memory),
-// the global lock mu protects the whole file system state,
-// and that's okay.
-type fsys struct {
-	mu   sync.Mutex
-	root *inode                    // root directory
-	cwd  *inode                    // process current directory
-	inum uint64                    // number of inodes created
-	dev  []func() (devFile, error) // table for opening devices
-}
-
-// A devFile is the implementation required of device files
-// like /dev/null or /dev/random.
-type devFile interface {
-	pread([]byte, int64) (int, error)
-	pwrite([]byte, int64) (int, error)
-}
-
-// An inode is a (possibly special) file in the file system.
-type inode struct {
-	Stat_t
-	data []byte
-	dir  []dirent
-}
-
-// A dirent describes a single directory entry.
-type dirent struct {
-	name  string
-	inode *inode
-}
-
-// An fsysFile is the fileImpl implementation backed by the file system.
-type fsysFile struct {
-	defaultFileImpl
-	fsys     *fsys
-	inode    *inode
-	openmode int
-	offset   int64
-	dev      devFile
-}
-
-// newFsys creates a new file system.
-func newFsys() *fsys {
-	fs := &fsys{}
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	ip := fs.newInode()
-	ip.Mode = 0555 | S_IFDIR
-	fs.dirlink(ip, ".", ip)
-	fs.dirlink(ip, "..", ip)
-	fs.cwd = ip
-	fs.root = ip
-	return fs
-}
-
-var fs = newFsys()
-var fsinit = func() {}
-
-func init() {
-	// do not trigger loading of zipped file system here
-	oldFsinit := fsinit
-	defer func() { fsinit = oldFsinit }()
-	fsinit = func() {}
-	Mkdir("/dev", 0555)
-	Mkdir("/tmp", 0777)
-	mkdev("/dev/null", 0666, openNull)
-	mkdev("/dev/random", 0444, openRandom)
-	mkdev("/dev/urandom", 0444, openRandom)
-	mkdev("/dev/zero", 0666, openZero)
-	chdirEnv()
-}
-
-func chdirEnv() {
-	pwd, ok := Getenv("NACLPWD")
-	if ok {
-		chdir(pwd)
-	}
-}
-
-// Except where indicated otherwise, unexported methods on fsys
-// expect fs.mu to have been locked by the caller.
-
-// newInode creates a new inode.
-func (fs *fsys) newInode() *inode {
-	fs.inum++
-	ip := &inode{
-		Stat_t: Stat_t{
-			Ino:     fs.inum,
-			Blksize: 512,
-		},
-	}
-	return ip
-}
-
-// atime sets ip.Atime to the current time.
-func (fs *fsys) atime(ip *inode) {
-	sec, nsec := now()
-	ip.Atime, ip.AtimeNsec = sec, int64(nsec)
-}
-
-// mtime sets ip.Mtime to the current time.
-func (fs *fsys) mtime(ip *inode) {
-	sec, nsec := now()
-	ip.Mtime, ip.MtimeNsec = sec, int64(nsec)
-}
-
-// dirlookup looks for an entry in the directory dp with the given name.
-// It returns the directory entry and its index within the directory.
-func (fs *fsys) dirlookup(dp *inode, name string) (de *dirent, index int, err error) {
-	fs.atime(dp)
-	for i := range dp.dir {
-		de := &dp.dir[i]
-		if de.name == name {
-			fs.atime(de.inode)
-			return de, i, nil
-		}
-	}
-	return nil, 0, ENOENT
-}
-
-// dirlink adds to the directory dp an entry for name pointing at the inode ip.
-// If dp already contains an entry for name, that entry is overwritten.
-func (fs *fsys) dirlink(dp *inode, name string, ip *inode) {
-	fs.mtime(dp)
-	fs.atime(ip)
-	ip.Nlink++
-	for i := range dp.dir {
-		if dp.dir[i].name == name {
-			dp.dir[i] = dirent{name, ip}
-			return
-		}
-	}
-	dp.dir = append(dp.dir, dirent{name, ip})
-	dp.dirSize()
-}
-
-func (dp *inode) dirSize() {
-	dp.Size = int64(len(dp.dir)) * (8 + 8 + 2 + 256) // Dirent
-}
-
-// skipelem splits path into the first element and the remainder.
-// the returned first element contains no slashes, and the returned
-// remainder does not begin with a slash.
-func skipelem(path string) (elem, rest string) {
-	for len(path) > 0 && path[0] == '/' {
-		path = path[1:]
-	}
-	if len(path) == 0 {
-		return "", ""
-	}
-	i := 0
-	for i < len(path) && path[i] != '/' {
-		i++
-	}
-	elem, path = path[:i], path[i:]
-	for len(path) > 0 && path[0] == '/' {
-		path = path[1:]
-	}
-	return elem, path
-}
-
-// namei translates a file system path name into an inode.
-// If parent is false, the returned ip corresponds to the given name, and elem is the empty string.
-// If parent is true, the walk stops at the next-to-last element in the name,
-// so that ip is the parent directory and elem is the final element in the path.
-func (fs *fsys) namei(path string, parent bool) (ip *inode, elem string, err error) {
-	// Reject NUL in name.
-	for i := 0; i < len(path); i++ {
-		if path[i] == '\x00' {
-			return nil, "", EINVAL
-		}
-	}
-
-	// Reject empty name.
-	if path == "" {
-		return nil, "", EINVAL
-	}
-
-	if path[0] == '/' {
-		ip = fs.root
-	} else {
-		ip = fs.cwd
-	}
-
-	for len(path) > 0 && path[len(path)-1] == '/' {
-		path = path[:len(path)-1]
-	}
-
-	for {
-		elem, rest := skipelem(path)
-		if elem == "" {
-			if parent && ip.Mode&S_IFMT == S_IFDIR {
-				return ip, ".", nil
-			}
-			break
-		}
-		if ip.Mode&S_IFMT != S_IFDIR {
-			return nil, "", ENOTDIR
-		}
-		if len(elem) >= 256 {
-			return nil, "", ENAMETOOLONG
-		}
-		if parent && rest == "" {
-			// Stop one level early.
-			return ip, elem, nil
-		}
-		de, _, err := fs.dirlookup(ip, elem)
-		if err != nil {
-			return nil, "", err
-		}
-		ip = de.inode
-		path = rest
-	}
-	if parent {
-		return nil, "", ENOTDIR
-	}
-	return ip, "", nil
-}
-
-// open opens or creates a file with the given name, open mode,
-// and permission mode bits.
-func (fs *fsys) open(name string, openmode int, mode uint32) (fileImpl, error) {
-	dp, elem, err := fs.namei(name, true)
-	if err != nil {
-		return nil, err
-	}
-	var (
-		ip  *inode
-		dev devFile
-	)
-	de, _, err := fs.dirlookup(dp, elem)
-	if err != nil {
-		if openmode&O_CREATE == 0 {
-			return nil, err
-		}
-		ip = fs.newInode()
-		ip.Mode = mode
-		fs.dirlink(dp, elem, ip)
-		if ip.Mode&S_IFMT == S_IFDIR {
-			fs.dirlink(ip, ".", ip)
-			fs.dirlink(ip, "..", dp)
-		}
-	} else {
-		ip = de.inode
-		if openmode&(O_CREATE|O_EXCL) == O_CREATE|O_EXCL {
-			return nil, EEXIST
-		}
-		if openmode&O_TRUNC != 0 {
-			if ip.Mode&S_IFMT == S_IFDIR {
-				return nil, EISDIR
-			}
-			ip.data = nil
-		}
-		if ip.Mode&S_IFMT == S_IFCHR {
-			if ip.Rdev < 0 || ip.Rdev >= int64(len(fs.dev)) || fs.dev[ip.Rdev] == nil {
-				return nil, ENODEV
-			}
-			dev, err = fs.dev[ip.Rdev]()
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-
-	switch openmode & O_ACCMODE {
-	case O_WRONLY, O_RDWR:
-		if ip.Mode&S_IFMT == S_IFDIR {
-			return nil, EISDIR
-		}
-	}
-
-	switch ip.Mode & S_IFMT {
-	case S_IFDIR:
-		if openmode&O_ACCMODE != O_RDONLY {
-			return nil, EISDIR
-		}
-
-	case S_IFREG:
-		// ok
-
-	case S_IFCHR:
-		// handled above
-
-	default:
-		// TODO: some kind of special file
-		return nil, EPERM
-	}
-
-	f := &fsysFile{
-		fsys:     fs,
-		inode:    ip,
-		openmode: openmode,
-		dev:      dev,
-	}
-	if openmode&O_APPEND != 0 {
-		f.offset = ip.Size
-	}
-	return f, nil
-}
-
-// fsysFile methods to implement fileImpl.
-
-func (f *fsysFile) stat(st *Stat_t) error {
-	f.fsys.mu.Lock()
-	defer f.fsys.mu.Unlock()
-	*st = f.inode.Stat_t
-	return nil
-}
-
-func (f *fsysFile) read(b []byte) (int, error) {
-	f.fsys.mu.Lock()
-	defer f.fsys.mu.Unlock()
-	n, err := f.preadLocked(b, f.offset)
-	f.offset += int64(n)
-	return n, err
-}
-
-func ReadDirent(fd int, buf []byte) (int, error) {
-	f, err := fdToFsysFile(fd)
-	if err != nil {
-		return 0, err
-	}
-	f.fsys.mu.Lock()
-	defer f.fsys.mu.Unlock()
-	if f.inode.Mode&S_IFMT != S_IFDIR {
-		return 0, EINVAL
-	}
-	n, err := f.preadLocked(buf, f.offset)
-	f.offset += int64(n)
-	return n, err
-}
-
-func (f *fsysFile) write(b []byte) (int, error) {
-	f.fsys.mu.Lock()
-	defer f.fsys.mu.Unlock()
-	n, err := f.pwriteLocked(b, f.offset)
-	f.offset += int64(n)
-	return n, err
-}
-
-func (f *fsysFile) seek(offset int64, whence int) (int64, error) {
-	f.fsys.mu.Lock()
-	defer f.fsys.mu.Unlock()
-	switch whence {
-	case 1:
-		offset += f.offset
-	case 2:
-		offset += f.inode.Size
-	}
-	if offset < 0 {
-		return 0, EINVAL
-	}
-	if offset > f.inode.Size {
-		return 0, EINVAL
-	}
-	f.offset = offset
-	return offset, nil
-}
-
-func (f *fsysFile) pread(b []byte, offset int64) (int, error) {
-	f.fsys.mu.Lock()
-	defer f.fsys.mu.Unlock()
-	return f.preadLocked(b, offset)
-}
-
-func (f *fsysFile) pwrite(b []byte, offset int64) (int, error) {
-	f.fsys.mu.Lock()
-	defer f.fsys.mu.Unlock()
-	return f.pwriteLocked(b, offset)
-}
-
-func (f *fsysFile) preadLocked(b []byte, offset int64) (int, error) {
-	if f.openmode&O_ACCMODE == O_WRONLY {
-		return 0, EINVAL
-	}
-	if offset < 0 {
-		return 0, EINVAL
-	}
-	if f.dev != nil {
-		f.fsys.atime(f.inode)
-		f.fsys.mu.Unlock()
-		defer f.fsys.mu.Lock()
-		return f.dev.pread(b, offset)
-	}
-	if offset > f.inode.Size {
-		return 0, nil
-	}
-	if int64(len(b)) > f.inode.Size-offset {
-		b = b[:f.inode.Size-offset]
-	}
-
-	if f.inode.Mode&S_IFMT == S_IFDIR {
-		if offset%direntSize != 0 || len(b) != 0 && len(b) < direntSize {
-			return 0, EINVAL
-		}
-		fs.atime(f.inode)
-		n := 0
-		for len(b) >= direntSize {
-			src := f.inode.dir[int(offset/direntSize)]
-			dst := (*Dirent)(unsafe.Pointer(&b[0]))
-			dst.Ino = int64(src.inode.Ino)
-			dst.Off = offset
-			dst.Reclen = direntSize
-			for i := range dst.Name {
-				dst.Name[i] = 0
-			}
-			copy(dst.Name[:], src.name)
-			n += direntSize
-			offset += direntSize
-			b = b[direntSize:]
-		}
-		return n, nil
-	}
-
-	fs.atime(f.inode)
-	n := copy(b, f.inode.data[offset:])
-	return n, nil
-}
-
-func (f *fsysFile) pwriteLocked(b []byte, offset int64) (int, error) {
-	if f.openmode&O_ACCMODE == O_RDONLY {
-		return 0, EINVAL
-	}
-	if offset < 0 {
-		return 0, EINVAL
-	}
-	if f.dev != nil {
-		f.fsys.atime(f.inode)
-		f.fsys.mu.Unlock()
-		defer f.fsys.mu.Lock()
-		return f.dev.pwrite(b, offset)
-	}
-	if offset > f.inode.Size {
-		return 0, EINVAL
-	}
-	f.fsys.mtime(f.inode)
-	n := copy(f.inode.data[offset:], b)
-	if n < len(b) {
-		f.inode.data = append(f.inode.data, b[n:]...)
-		f.inode.Size = int64(len(f.inode.data))
-	}
-	return len(b), nil
-}
-
-// Standard Unix system calls.
-
-func Open(path string, openmode int, perm uint32) (fd int, err error) {
-	fsinit()
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	f, err := fs.open(path, openmode, perm&0777|S_IFREG)
-	if err != nil {
-		return -1, err
-	}
-	return newFD(f), nil
-}
-
-func Mkdir(path string, perm uint32) error {
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	_, err := fs.open(path, O_CREATE|O_EXCL, perm&0777|S_IFDIR)
-	return err
-}
-
-func Getcwd(buf []byte) (n int, err error) {
-	// Force package os to default to the old algorithm using .. and directory reads.
-	return 0, ENOSYS
-}
-
-func Stat(path string, st *Stat_t) error {
-	fsinit()
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	ip, _, err := fs.namei(path, false)
-	if err != nil {
-		return err
-	}
-	*st = ip.Stat_t
-	return nil
-}
-
-func Lstat(path string, st *Stat_t) error {
-	return Stat(path, st)
-}
-
-func unlink(path string, isdir bool) error {
-	fsinit()
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	dp, elem, err := fs.namei(path, true)
-	if err != nil {
-		return err
-	}
-	if elem == "." || elem == ".." {
-		return EINVAL
-	}
-	de, _, err := fs.dirlookup(dp, elem)
-	if err != nil {
-		return err
-	}
-	if isdir {
-		if de.inode.Mode&S_IFMT != S_IFDIR {
-			return ENOTDIR
-		}
-		if len(de.inode.dir) != 2 {
-			return ENOTEMPTY
-		}
-	} else {
-		if de.inode.Mode&S_IFMT == S_IFDIR {
-			return EISDIR
-		}
-	}
-	de.inode.Nlink--
-	*de = dp.dir[len(dp.dir)-1]
-	dp.dir = dp.dir[:len(dp.dir)-1]
-	dp.dirSize()
-	return nil
-}
-
-func Unlink(path string) error {
-	return unlink(path, false)
-}
-
-func Rmdir(path string) error {
-	return unlink(path, true)
-}
-
-func Chmod(path string, mode uint32) error {
-	fsinit()
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	ip, _, err := fs.namei(path, false)
-	if err != nil {
-		return err
-	}
-	ip.Mode = ip.Mode&^0777 | mode&0777
-	return nil
-}
-
-func Fchmod(fd int, mode uint32) error {
-	f, err := fdToFsysFile(fd)
-	if err != nil {
-		return err
-	}
-	f.fsys.mu.Lock()
-	defer f.fsys.mu.Unlock()
-	f.inode.Mode = f.inode.Mode&^0777 | mode&0777
-	return nil
-}
-
-func Chown(path string, uid, gid int) error {
-	fsinit()
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	ip, _, err := fs.namei(path, false)
-	if err != nil {
-		return err
-	}
-	ip.Uid = uint32(uid)
-	ip.Gid = uint32(gid)
-	return nil
-}
-
-func Fchown(fd int, uid, gid int) error {
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	f, err := fdToFsysFile(fd)
-	if err != nil {
-		return err
-	}
-	f.fsys.mu.Lock()
-	defer f.fsys.mu.Unlock()
-	f.inode.Uid = uint32(uid)
-	f.inode.Gid = uint32(gid)
-	return nil
-}
-
-func Lchown(path string, uid, gid int) error {
-	return Chown(path, uid, gid)
-}
-
-func UtimesNano(path string, ts []Timespec) error {
-	if len(ts) != 2 {
-		return EINVAL
-	}
-	fsinit()
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	ip, _, err := fs.namei(path, false)
-	if err != nil {
-		return err
-	}
-	ip.Atime = ts[0].Sec
-	ip.AtimeNsec = int64(ts[0].Nsec)
-	ip.Mtime = ts[1].Sec
-	ip.MtimeNsec = int64(ts[1].Nsec)
-	return nil
-}
-
-func Link(path, link string) error {
-	fsinit()
-	ip, _, err := fs.namei(path, false)
-	if err != nil {
-		return err
-	}
-	dp, elem, err := fs.namei(link, true)
-	if err != nil {
-		return err
-	}
-	if ip.Mode&S_IFMT == S_IFDIR {
-		return EPERM
-	}
-	fs.dirlink(dp, elem, ip)
-	return nil
-}
-
-func Rename(from, to string) error {
-	fsinit()
-	fdp, felem, err := fs.namei(from, true)
-	if err != nil {
-		return err
-	}
-	fde, _, err := fs.dirlookup(fdp, felem)
-	if err != nil {
-		return err
-	}
-	tdp, telem, err := fs.namei(to, true)
-	if err != nil {
-		return err
-	}
-	fs.dirlink(tdp, telem, fde.inode)
-	fde.inode.Nlink--
-	*fde = fdp.dir[len(fdp.dir)-1]
-	fdp.dir = fdp.dir[:len(fdp.dir)-1]
-	fdp.dirSize()
-	return nil
-}
-
-func (fs *fsys) truncate(ip *inode, length int64) error {
-	if length > 1e9 || ip.Mode&S_IFMT != S_IFREG {
-		return EINVAL
-	}
-	if length < int64(len(ip.data)) {
-		ip.data = ip.data[:length]
-	} else {
-		data := make([]byte, length)
-		copy(data, ip.data)
-		ip.data = data
-	}
-	ip.Size = int64(len(ip.data))
-	return nil
-}
-
-func Truncate(path string, length int64) error {
-	fsinit()
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	ip, _, err := fs.namei(path, false)
-	if err != nil {
-		return err
-	}
-	return fs.truncate(ip, length)
-}
-
-func Ftruncate(fd int, length int64) error {
-	f, err := fdToFsysFile(fd)
-	if err != nil {
-		return err
-	}
-	f.fsys.mu.Lock()
-	defer f.fsys.mu.Unlock()
-	return f.fsys.truncate(f.inode, length)
-}
-
-func Chdir(path string) error {
-	fsinit()
-	return chdir(path)
-}
-
-func chdir(path string) error {
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	ip, _, err := fs.namei(path, false)
-	if err != nil {
-		return err
-	}
-	fs.cwd = ip
-	return nil
-}
-
-func Fchdir(fd int) error {
-	f, err := fdToFsysFile(fd)
-	if err != nil {
-		return err
-	}
-	f.fsys.mu.Lock()
-	defer f.fsys.mu.Unlock()
-	if f.inode.Mode&S_IFMT != S_IFDIR {
-		return ENOTDIR
-	}
-	fs.cwd = f.inode
-	return nil
-}
-
-func Readlink(path string, buf []byte) (n int, err error) {
-	return 0, ENOSYS
-}
-
-func Symlink(path, link string) error {
-	return ENOSYS
-}
-
-func Fsync(fd int) error {
-	return nil
-}
-
-// Special devices.
-
-func mkdev(path string, mode uint32, open func() (devFile, error)) error {
-	f, err := fs.open(path, O_CREATE|O_RDONLY|O_EXCL, S_IFCHR|mode)
-	if err != nil {
-		return err
-	}
-	ip := f.(*fsysFile).inode
-	ip.Rdev = int64(len(fs.dev))
-	fs.dev = append(fs.dev, open)
-	return nil
-}
-
-type nullFile struct{}
-
-func openNull() (devFile, error)                               { return &nullFile{}, nil }
-func (f *nullFile) close() error                               { return nil }
-func (f *nullFile) pread(b []byte, offset int64) (int, error)  { return 0, nil }
-func (f *nullFile) pwrite(b []byte, offset int64) (int, error) { return len(b), nil }
-
-type zeroFile struct{}
-
-func openZero() (devFile, error)                               { return &zeroFile{}, nil }
-func (f *zeroFile) close() error                               { return nil }
-func (f *zeroFile) pwrite(b []byte, offset int64) (int, error) { return len(b), nil }
-
-func (f *zeroFile) pread(b []byte, offset int64) (int, error) {
-	for i := range b {
-		b[i] = 0
-	}
-	return len(b), nil
-}
-
-type randomFile struct {
-	naclFD int
-}
-
-func openRandom() (devFile, error) {
-	fd, err := openNamedService("SecureRandom", O_RDONLY)
-	if err != nil {
-		return nil, err
-	}
-	return &randomFile{naclFD: fd}, nil
-}
-
-func (f *randomFile) close() error {
-	naclClose(f.naclFD)
-	f.naclFD = -1
-	return nil
-}
-
-func (f *randomFile) pread(b []byte, offset int64) (int, error) {
-	return naclRead(f.naclFD, b)
-}
-
-func (f *randomFile) pwrite(b []byte, offset int64) (int, error) {
-	return 0, EPERM
-}
-
-func fdToFsysFile(fd int) (*fsysFile, error) {
-	f, err := fdToFile(fd)
-	if err != nil {
-		return nil, err
-	}
-	impl := f.impl
-	fsysf, ok := impl.(*fsysFile)
-	if !ok {
-		return nil, EINVAL
-	}
-	return fsysf, nil
-}
-
-// create creates a file in the file system with the given name, mode, time, and data.
-// It is meant to be called when initializing the file system image.
-func create(name string, mode uint32, sec int64, data []byte) error {
-	fs.mu.Lock()
-	fs.mu.Unlock()
-	f, err := fs.open(name, O_CREATE|O_EXCL, mode)
-	if err != nil {
-		return err
-	}
-	ip := f.(*fsysFile).inode
-	ip.Atime = sec
-	ip.Mtime = sec
-	ip.Ctime = sec
-	if len(data) > 0 {
-		ip.Size = int64(len(data))
-		ip.data = data
-	}
-	return nil
-}

unix/mkall.sh

@@ -176,18 +176,6 @@ linux_arm)
 	mksysnum="curl -s 'http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/plain/arch/arm/include/uapi/asm/unistd.h' | ./mksysnum_linux.pl"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
 	;;
-nacl_386)
-	mkerrors=""
-	mksyscall="./mksyscall.pl -l32 -nacl"
-	mksysnum=""
-	mktypes=""
-	;;
-nacl_amd64p32)
-	mkerrors=""
-	mksyscall="./mksyscall.pl -nacl"
-	mksysnum=""
-	mktypes=""
-	;;
 netbsd_386)
 	mkerrors="$mkerrors -m32"
 	mksyscall="./mksyscall.pl -l32 -netbsd"

unix/mksyscall.pl

@@ -28,7 +28,6 @@ my $plan9 = 0;
 my $openbsd = 0;
 my $netbsd = 0;
 my $dragonfly = 0;
-my $nacl = 0;
 my $arm = 0; # 64-bit value should use (even, odd)-pair
 
 if($ARGV[0] eq "-b32") {
@@ -54,10 +53,6 @@ if($ARGV[0] eq "-dragonfly") {
 	$dragonfly = 1;
 	shift;
 }
-if($ARGV[0] eq "-nacl") {
-	$nacl = 1;
-	shift;
-}
 if($ARGV[0] eq "-arm") {
 	$arm = 1;
 	shift;
@@ -224,9 +219,6 @@ while(<>) {
 		$sysname = "SYS_$func";
 		$sysname =~ s/([a-z])([A-Z])/${1}_$2/g;	# turn FooBar into Foo_Bar
 		$sysname =~ y/a-z/A-Z/;
-		if($nacl) {
-			$sysname =~ y/A-Z/a-z/;
-		}
 	}
 
 	# Actual call.

unix/net_nacl.go

@@ -1,912 +0,0 @@
-// Copyright 2013 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.
-
-// A simulated network for use within NaCl.
-// The simulation is not particularly tied to NaCl,
-// but other systems have real networks.
-
-package unix
-
-import (
-	"sync"
-	"sync/atomic"
-)
-
-// Interface to timers implemented in package runtime.
-// Must be in sync with ../runtime/runtime.h:/^struct.Timer$
-// Really for use by package time, but we cannot import time here.
-
-type runtimeTimer struct {
-	i      int32
-	when   int64
-	period int64
-	f      func(int64, interface{}) // NOTE: must not be closure
-	arg    interface{}
-}
-
-func startTimer(*runtimeTimer)
-func stopTimer(*runtimeTimer) bool
-
-type timer struct {
-	expired bool
-	q       *queue
-	r       runtimeTimer
-}
-
-func (t *timer) start(q *queue, deadline int64) {
-	if deadline == 0 {
-		return
-	}
-	t.q = q
-	t.r.when = deadline
-	t.r.f = timerExpired
-	t.r.arg = t
-	startTimer(&t.r)
-}
-
-func (t *timer) stop() {
-	stopTimer(&t.r)
-}
-
-func timerExpired(now int64, i interface{}) {
-	t := i.(*timer)
-	go func() {
-		t.q.Lock()
-		defer t.q.Unlock()
-		t.expired = true
-		t.q.canRead.Broadcast()
-		t.q.canWrite.Broadcast()
-	}()
-}
-
-// Network constants and data structures. These match the traditional values.
-
-const (
-	AF_UNSPEC = iota
-	AF_UNIX
-	AF_INET
-	AF_INET6
-)
-
-const (
-	SHUT_RD = iota
-	SHUT_WR
-	SHUT_RDWR
-)
-
-const (
-	SOCK_STREAM = 1 + iota
-	SOCK_DGRAM
-	SOCK_RAW
-	SOCK_SEQPACKET
-)
-
-const (
-	IPPROTO_IP   = 0
-	IPPROTO_IPV4 = 4
-	IPPROTO_IPV6 = 0x29
-	IPPROTO_TCP  = 6
-	IPPROTO_UDP  = 0x11
-)
-
-// Misc constants expected by package net but not supported.
-const (
-	_ = iota
-	SOL_SOCKET
-	SO_TYPE
-	NET_RT_IFLIST
-	IFNAMSIZ
-	IFF_UP
-	IFF_BROADCAST
-	IFF_LOOPBACK
-	IFF_POINTOPOINT
-	IFF_MULTICAST
-	IPV6_V6ONLY
-	SOMAXCONN
-	F_DUPFD_CLOEXEC
-	SO_BROADCAST
-	SO_REUSEADDR
-	SO_REUSEPORT
-	SO_RCVBUF
-	SO_SNDBUF
-	SO_KEEPALIVE
-	SO_LINGER
-	SO_ERROR
-	IP_PORTRANGE
-	IP_PORTRANGE_DEFAULT
-	IP_PORTRANGE_LOW
-	IP_PORTRANGE_HIGH
-	IP_MULTICAST_IF
-	IP_MULTICAST_LOOP
-	IP_ADD_MEMBERSHIP
-	IPV6_PORTRANGE
-	IPV6_PORTRANGE_DEFAULT
-	IPV6_PORTRANGE_LOW
-	IPV6_PORTRANGE_HIGH
-	IPV6_MULTICAST_IF
-	IPV6_MULTICAST_LOOP
-	IPV6_JOIN_GROUP
-	TCP_NODELAY
-	TCP_KEEPINTVL
-	TCP_KEEPIDLE
-
-	SYS_FCNTL = 500 // unsupported
-)
-
-var SocketDisableIPv6 bool
-
-// A Sockaddr is one of the SockaddrXxx structs.
-type Sockaddr interface {
-	// copy returns a copy of the underlying data.
-	copy() Sockaddr
-
-	// key returns the value of the underlying data,
-	// for comparison as a map key.
-	key() interface{}
-}
-
-type SockaddrInet4 struct {
-	Port int
-	Addr [4]byte
-}
-
-func (sa *SockaddrInet4) copy() Sockaddr {
-	sa1 := *sa
-	return &sa1
-}
-
-func (sa *SockaddrInet4) key() interface{} { return *sa }
-
-type SockaddrInet6 struct {
-	Port   int
-	ZoneId uint32
-	Addr   [16]byte
-}
-
-func (sa *SockaddrInet6) copy() Sockaddr {
-	sa1 := *sa
-	return &sa1
-}
-
-func (sa *SockaddrInet6) key() interface{} { return *sa }
-
-type SockaddrUnix struct {
-	Name string
-}
-
-func (sa *SockaddrUnix) copy() Sockaddr {
-	sa1 := *sa
-	return &sa1
-}
-
-func (sa *SockaddrUnix) key() interface{} { return *sa }
-
-type SockaddrDatalink struct {
-	Len    uint8
-	Family uint8
-	Index  uint16
-	Type   uint8
-	Nlen   uint8
-	Alen   uint8
-	Slen   uint8
-	Data   [12]int8
-}
-
-func (sa *SockaddrDatalink) copy() Sockaddr {
-	sa1 := *sa
-	return &sa1
-}
-
-func (sa *SockaddrDatalink) key() interface{} { return *sa }
-
-// RoutingMessage represents a routing message.
-type RoutingMessage interface {
-	unimplemented()
-}
-
-type IPMreq struct {
-	Multiaddr [4]byte /* in_addr */
-	Interface [4]byte /* in_addr */
-}
-
-type IPv6Mreq struct {
-	Multiaddr [16]byte /* in6_addr */
-	Interface uint32
-}
-
-type Linger struct {
-	Onoff  int32
-	Linger int32
-}
-
-type ICMPv6Filter struct {
-	Filt [8]uint32
-}
-
-// A queue is the bookkeeping for a synchronized buffered queue.
-// We do not use channels because we need to be able to handle
-// writes after and during close, and because a chan byte would
-// require too many send and receive operations in real use.
-type queue struct {
-	sync.Mutex
-	canRead  sync.Cond
-	canWrite sync.Cond
-	r        int // total read index
-	w        int // total write index
-	m        int // index mask
-	closed   bool
-}
-
-func (q *queue) init(size int) {
-	if size&(size-1) != 0 {
-		panic("invalid queue size - must be power of two")
-	}
-	q.canRead.L = &q.Mutex
-	q.canWrite.L = &q.Mutex
-	q.m = size - 1
-}
-
-func past(deadline int64) bool {
-	sec, nsec := now()
-	return deadline > 0 && deadline < sec*1e9+int64(nsec)
-}
-
-func (q *queue) waitRead(n int, deadline int64) (int, error) {
-	if past(deadline) {
-		return 0, EAGAIN
-	}
-	var t timer
-	t.start(q, deadline)
-	for q.w-q.r == 0 && !q.closed && !t.expired {
-		q.canRead.Wait()
-	}
-	t.stop()
-	m := q.w - q.r
-	if m == 0 && t.expired {
-		return 0, EAGAIN
-	}
-	if m > n {
-		m = n
-		q.canRead.Signal() // wake up next reader too
-	}
-	q.canWrite.Signal()
-	return m, nil
-}
-
-func (q *queue) waitWrite(n int, deadline int64) (int, error) {
-	if past(deadline) {
-		return 0, EAGAIN
-	}
-	var t timer
-	t.start(q, deadline)
-	for q.w-q.r > q.m && !q.closed && !t.expired {
-		q.canWrite.Wait()
-	}
-	t.stop()
-	m := q.m + 1 - (q.w - q.r)
-	if m == 0 && t.expired {
-		return 0, EAGAIN
-	}
-	if m == 0 {
-		return 0, EAGAIN
-	}
-	if m > n {
-		m = n
-		q.canWrite.Signal() // wake up next writer too
-	}
-	q.canRead.Signal()
-	return m, nil
-}
-
-func (q *queue) close() {
-	q.Lock()
-	defer q.Unlock()
-	q.closed = true
-	q.canRead.Broadcast()
-	q.canWrite.Broadcast()
-}
-
-// A byteq is a byte queue.
-type byteq struct {
-	queue
-	data []byte
-}
-
-func newByteq() *byteq {
-	q := &byteq{
-		data: make([]byte, 4096),
-	}
-	q.init(len(q.data))
-	return q
-}
-
-func (q *byteq) read(b []byte, deadline int64) (int, error) {
-	q.Lock()
-	defer q.Unlock()
-	n, err := q.waitRead(len(b), deadline)
-	if err != nil {
-		return 0, err
-	}
-	b = b[:n]
-	for len(b) > 0 {
-		m := copy(b, q.data[q.r&q.m:])
-		q.r += m
-		b = b[m:]
-	}
-	return n, nil
-}
-
-func (q *byteq) write(b []byte, deadline int64) (n int, err error) {
-	q.Lock()
-	defer q.Unlock()
-	for n < len(b) {
-		nn, err := q.waitWrite(len(b[n:]), deadline)
-		if err != nil {
-			return n, err
-		}
-		bb := b[n : n+nn]
-		n += nn
-		for len(bb) > 0 {
-			m := copy(q.data[q.w&q.m:], bb)
-			q.w += m
-			bb = bb[m:]
-		}
-	}
-	return n, nil
-}
-
-// A msgq is a queue of messages.
-type msgq struct {
-	queue
-	data []interface{}
-}
-
-func newMsgq() *msgq {
-	q := &msgq{
-		data: make([]interface{}, 32),
-	}
-	q.init(len(q.data))
-	return q
-}
-
-func (q *msgq) read(deadline int64) (interface{}, error) {
-	q.Lock()
-	defer q.Unlock()
-	n, err := q.waitRead(1, deadline)
-	if err != nil {
-		return nil, err
-	}
-	if n == 0 {
-		return nil, nil
-	}
-	m := q.data[q.r&q.m]
-	q.r++
-	return m, nil
-}
-
-func (q *msgq) write(m interface{}, deadline int64) error {
-	q.Lock()
-	defer q.Unlock()
-	_, err := q.waitWrite(1, deadline)
-	if err != nil {
-		return err
-	}
-	q.data[q.w&q.m] = m
-	q.w++
-	return nil
-}
-
-// An addr is a sequence of bytes uniquely identifying a network address.
-// It is not human-readable.
-type addr string
-
-// A conn is one side of a stream-based network connection.
-// That is, a stream-based network connection is a pair of cross-connected conns.
-type conn struct {
-	rd     *byteq
-	wr     *byteq
-	local  addr
-	remote addr
-}
-
-// A pktconn is one side of a packet-based network connection.
-// That is, a packet-based network connection is a pair of cross-connected pktconns.
-type pktconn struct {
-	rd     *msgq
-	wr     *msgq
-	local  addr
-	remote addr
-}
-
-// A listener accepts incoming stream-based network connections.
-type listener struct {
-	rd    *msgq
-	local addr
-}
-
-// A netFile is an open network file.
-type netFile struct {
-	defaultFileImpl
-	proto      *netproto
-	sotype     int
-	listener   *msgq
-	packet     *msgq
-	rd         *byteq
-	wr         *byteq
-	rddeadline int64
-	wrdeadline int64
-	addr       Sockaddr
-	raddr      Sockaddr
-}
-
-// A netAddr is a network address in the global listener map.
-// All the fields must have defined == operations.
-type netAddr struct {
-	proto  *netproto
-	sotype int
-	addr   interface{}
-}
-
-// net records the state of the network.
-// It maps a network address to the listener on that address.
-var net = struct {
-	sync.Mutex
-	listener map[netAddr]*netFile
-}{
-	listener: make(map[netAddr]*netFile),
-}
-
-// TODO(rsc): Some day, do a better job with port allocation.
-// For playground programs, incrementing is fine.
-var nextport = 2
-
-// A netproto contains protocol-specific functionality
-// (one for AF_INET, one for AF_INET6 and so on).
-// It is a struct instead of an interface because the
-// implementation needs no state, and I expect to
-// add some data fields at some point.
-type netproto struct {
-	bind func(*netFile, Sockaddr) error
-}
-
-var netprotoAF_INET = &netproto{
-	bind: func(f *netFile, sa Sockaddr) error {
-		if sa == nil {
-			f.addr = &SockaddrInet4{
-				Port: nextport,
-				Addr: [4]byte{127, 0, 0, 1},
-			}
-			nextport++
-			return nil
-		}
-		addr, ok := sa.(*SockaddrInet4)
-		if !ok {
-			return EINVAL
-		}
-		addr = addr.copy().(*SockaddrInet4)
-		if addr.Port == 0 {
-			addr.Port = nextport
-			nextport++
-		}
-		f.addr = addr
-		return nil
-	},
-}
-
-var netprotos = map[int]*netproto{
-	AF_INET: netprotoAF_INET,
-}
-
-// These functions implement the usual BSD socket operations.
-
-func (f *netFile) bind(sa Sockaddr) error {
-	if f.addr != nil {
-		return EISCONN
-	}
-	if err := f.proto.bind(f, sa); err != nil {
-		return err
-	}
-	if f.sotype == SOCK_DGRAM {
-		_, ok := net.listener[netAddr{f.proto, f.sotype, f.addr.key()}]
-		if ok {
-			f.addr = nil
-			return EADDRINUSE
-		}
-		net.listener[netAddr{f.proto, f.sotype, f.addr.key()}] = f
-		f.packet = newMsgq()
-	}
-	return nil
-}
-
-func (f *netFile) listen(backlog int) error {
-	net.Lock()
-	defer net.Unlock()
-	if f.listener != nil {
-		return EINVAL
-	}
-	_, ok := net.listener[netAddr{f.proto, f.sotype, f.addr.key()}]
-	if ok {
-		return EADDRINUSE
-	}
-	net.listener[netAddr{f.proto, f.sotype, f.addr.key()}] = f
-	f.listener = newMsgq()
-	return nil
-}
-
-func (f *netFile) accept() (fd int, sa Sockaddr, err error) {
-	msg, err := f.listener.read(f.readDeadline())
-	if err != nil {
-		return -1, nil, err
-	}
-	newf, ok := msg.(*netFile)
-	if !ok {
-		// must be eof
-		return -1, nil, EAGAIN
-	}
-	return newFD(newf), newf.raddr.copy(), nil
-}
-
-func (f *netFile) connect(sa Sockaddr) error {
-	if past(f.writeDeadline()) {
-		return EAGAIN
-	}
-	if f.addr == nil {
-		if err := f.bind(nil); err != nil {
-			return err
-		}
-	}
-	net.Lock()
-	if sa == nil {
-		net.Unlock()
-		return EINVAL
-	}
-	sa = sa.copy()
-	if f.raddr != nil {
-		net.Unlock()
-		return EISCONN
-	}
-	if f.sotype == SOCK_DGRAM {
-		net.Unlock()
-		f.raddr = sa
-		return nil
-	}
-	if f.listener != nil {
-		net.Unlock()
-		return EISCONN
-	}
-	l, ok := net.listener[netAddr{f.proto, f.sotype, sa.key()}]
-	if !ok {
-		net.Unlock()
-		return ECONNREFUSED
-	}
-	f.raddr = sa
-	f.rd = newByteq()
-	f.wr = newByteq()
-	newf := &netFile{
-		proto:  f.proto,
-		sotype: f.sotype,
-		addr:   f.raddr,
-		raddr:  f.addr,
-		rd:     f.wr,
-		wr:     f.rd,
-	}
-	net.Unlock()
-	l.listener.write(newf, f.writeDeadline())
-	return nil
-}
-
-func (f *netFile) read(b []byte) (int, error) {
-	if f.rd == nil {
-		if f.raddr != nil {
-			n, _, err := f.recvfrom(b, 0)
-			return n, err
-		}
-		return 0, ENOTCONN
-	}
-	return f.rd.read(b, f.readDeadline())
-}
-
-func (f *netFile) write(b []byte) (int, error) {
-	if f.wr == nil {
-		if f.raddr != nil {
-			err := f.sendto(b, 0, f.raddr)
-			var n int
-			if err == nil {
-				n = len(b)
-			}
-			return n, err
-		}
-		return 0, ENOTCONN
-	}
-	return f.wr.write(b, f.writeDeadline())
-}
-
-type pktmsg struct {
-	buf  []byte
-	addr Sockaddr
-}
-
-func (f *netFile) recvfrom(p []byte, flags int) (n int, from Sockaddr, err error) {
-	if f.sotype != SOCK_DGRAM {
-		return 0, nil, EINVAL
-	}
-	if f.packet == nil {
-		return 0, nil, ENOTCONN
-	}
-	msg1, err := f.packet.read(f.readDeadline())
-	if err != nil {
-		return 0, nil, err
-	}
-	msg, ok := msg1.(*pktmsg)
-	if !ok {
-		return 0, nil, EAGAIN
-	}
-	return copy(p, msg.buf), msg.addr, nil
-}
-
-func (f *netFile) sendto(p []byte, flags int, to Sockaddr) error {
-	if f.sotype != SOCK_DGRAM {
-		return EINVAL
-	}
-	if f.packet == nil {
-		if err := f.bind(nil); err != nil {
-			return err
-		}
-	}
-	net.Lock()
-	if to == nil {
-		net.Unlock()
-		return EINVAL
-	}
-	to = to.copy()
-	l, ok := net.listener[netAddr{f.proto, f.sotype, to.key()}]
-	if !ok || l.packet == nil {
-		net.Unlock()
-		return ECONNREFUSED
-	}
-	net.Unlock()
-	msg := &pktmsg{
-		buf:  make([]byte, len(p)),
-		addr: f.addr,
-	}
-	copy(msg.buf, p)
-	l.packet.write(msg, f.writeDeadline())
-	return nil
-}
-
-func (f *netFile) close() error {
-	if f.listener != nil {
-		f.listener.close()
-	}
-	if f.packet != nil {
-		f.packet.close()
-	}
-	if f.rd != nil {
-		f.rd.close()
-	}
-	if f.wr != nil {
-		f.wr.close()
-	}
-	return nil
-}
-
-func fdToNetFile(fd int) (*netFile, error) {
-	f, err := fdToFile(fd)
-	if err != nil {
-		return nil, err
-	}
-	impl := f.impl
-	netf, ok := impl.(*netFile)
-	if !ok {
-		return nil, EINVAL
-	}
-	return netf, nil
-}
-
-func Socket(proto, sotype, unused int) (fd int, err error) {
-	p := netprotos[proto]
-	if p == nil {
-		return -1, EPROTONOSUPPORT
-	}
-	if sotype != SOCK_STREAM && sotype != SOCK_DGRAM {
-		return -1, ESOCKTNOSUPPORT
-	}
-	f := &netFile{
-		proto:  p,
-		sotype: sotype,
-	}
-	return newFD(f), nil
-}
-
-func Bind(fd int, sa Sockaddr) error {
-	f, err := fdToNetFile(fd)
-	if err != nil {
-		return err
-	}
-	return f.bind(sa)
-}
-
-func StopIO(fd int) error {
-	f, err := fdToNetFile(fd)
-	if err != nil {
-		return err
-	}
-	f.close()
-	return nil
-}
-
-func Listen(fd int, backlog int) error {
-	f, err := fdToNetFile(fd)
-	if err != nil {
-		return err
-	}
-	return f.listen(backlog)
-}
-
-func Accept(fd int) (newfd int, sa Sockaddr, err error) {
-	f, err := fdToNetFile(fd)
-	if err != nil {
-		return 0, nil, err
-	}
-	return f.accept()
-}
-
-func Getsockname(fd int) (sa Sockaddr, err error) {
-	f, err := fdToNetFile(fd)
-	if err != nil {
-		return nil, err
-	}
-	if f.addr == nil {
-		return nil, ENOTCONN
-	}
-	return f.addr.copy(), nil
-}
-
-func Getpeername(fd int) (sa Sockaddr, err error) {
-	f, err := fdToNetFile(fd)
-	if err != nil {
-		return nil, err
-	}
-	if f.raddr == nil {
-		return nil, ENOTCONN
-	}
-	return f.raddr.copy(), nil
-}
-
-func Connect(fd int, sa Sockaddr) error {
-	f, err := fdToNetFile(fd)
-	if err != nil {
-		return err
-	}
-	return f.connect(sa)
-}
-
-func Recvfrom(fd int, p []byte, flags int) (n int, from Sockaddr, err error) {
-	f, err := fdToNetFile(fd)
-	if err != nil {
-		return 0, nil, err
-	}
-	return f.recvfrom(p, flags)
-}
-
-func Sendto(fd int, p []byte, flags int, to Sockaddr) error {
-	f, err := fdToNetFile(fd)
-	if err != nil {
-		return err
-	}
-	return f.sendto(p, flags, to)
-}
-
-func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn, recvflags int, from Sockaddr, err error) {
-	f, err := fdToNetFile(fd)
-	if err != nil {
-		return
-	}
-	n, from, err = f.recvfrom(p, flags)
-	return
-}
-
-func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) error {
-	_, err := SendmsgN(fd, p, oob, to, flags)
-	return err
-}
-
-func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) {
-	f, err := fdToNetFile(fd)
-	if err != nil {
-		return 0, err
-	}
-	switch f.sotype {
-	case SOCK_STREAM:
-		n, err = f.write(p)
-	case SOCK_DGRAM:
-		n = len(p)
-		err = f.sendto(p, flags, to)
-	}
-	if err != nil {
-		return 0, err
-	}
-	return n, nil
-}
-
-func GetsockoptInt(fd, level, opt int) (value int, err error) {
-	f, err := fdToNetFile(fd)
-	if err != nil {
-		return 0, err
-	}
-	switch {
-	case level == SOL_SOCKET && opt == SO_TYPE:
-		return f.sotype, nil
-	}
-	return 0, ENOTSUP
-}
-
-func SetsockoptInt(fd, level, opt int, value int) error {
-	return nil
-}
-
-func SetsockoptByte(fd, level, opt int, value byte) error {
-	_, err := fdToNetFile(fd)
-	if err != nil {
-		return err
-	}
-	return ENOTSUP
-}
-
-func SetsockoptLinger(fd, level, opt int, l *Linger) error {
-	return nil
-}
-
-func SetReadDeadline(fd int, t int64) error {
-	f, err := fdToNetFile(fd)
-	if err != nil {
-		return err
-	}
-	atomic.StoreInt64(&f.rddeadline, t)
-	return nil
-}
-
-func (f *netFile) readDeadline() int64 {
-	return atomic.LoadInt64(&f.rddeadline)
-}
-
-func SetWriteDeadline(fd int, t int64) error {
-	f, err := fdToNetFile(fd)
-	if err != nil {
-		return err
-	}
-	atomic.StoreInt64(&f.wrdeadline, t)
-	return nil
-}
-
-func (f *netFile) writeDeadline() int64 {
-	return atomic.LoadInt64(&f.wrdeadline)
-}
-
-func Shutdown(fd int, how int) error {
-	f, err := fdToNetFile(fd)
-	if err != nil {
-		return err
-	}
-	switch how {
-	case SHUT_RD:
-		f.rd.close()
-	case SHUT_WR:
-		f.wr.close()
-	case SHUT_RDWR:
-		f.rd.close()
-		f.wr.close()
-	}
-	return nil
-}
-
-func SetsockoptICMPv6Filter(fd, level, opt int, filter *ICMPv6Filter) error { panic("SetsockoptICMPv") }
-func SetsockoptIPMreq(fd, level, opt int, mreq *IPMreq) error               { panic("SetsockoptIPMreq") }
-func SetsockoptIPv6Mreq(fd, level, opt int, mreq *IPv6Mreq) error           { panic("SetsockoptIPv") }
-func SetsockoptInet4Addr(fd, level, opt int, value [4]byte) error           { panic("SetsockoptInet") }
-func SetsockoptString(fd, level, opt int, s string) error                   { panic("SetsockoptString") }
-func SetsockoptTimeval(fd, level, opt int, tv *Timeval) error               { panic("SetsockoptTimeval") }
-func Socketpair(domain, typ, proto int) (fd [2]int, err error)              { panic("Socketpair") }
-
-func SetNonblock(fd int, nonblocking bool) error { return nil }

unix/srpc_nacl.go

@@ -1,822 +0,0 @@
-// Copyright 2013 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.
-
-// Native Client SRPC message passing.
-// This code is needed to invoke SecureRandom, the NaCl equivalent of /dev/random.
-
-package unix
-
-import (
-	"errors"
-	"sync"
-	"unsafe"
-)
-
-// An srpcClient represents the client side of an SRPC connection.
-type srpcClient struct {
-	fd      int // to server
-	r       msgReceiver
-	s       msgSender
-	service map[string]srpcService // services by name
-
-	outMu sync.Mutex // protects writing to connection
-
-	mu      sync.Mutex // protects following fields
-	muxer   bool       // is someone reading and muxing responses
-	pending map[uint32]*srpc
-	idGen   uint32 // generator for request IDs
-}
-
-// An srpcService is a single method that the server offers.
-type srpcService struct {
-	num uint32 // method number
-	fmt string // argument format; see "parsing of RPC messages" below
-}
-
-// An srpc represents a single srpc issued by a client.
-type srpc struct {
-	Ret  []interface{}
-	Done chan *srpc
-	Err  error
-	c    *srpcClient
-	id   uint32
-}
-
-// newClient allocates a new SRPC client using the file descriptor fd.
-func newClient(fd int) (*srpcClient, error) {
-	c := new(srpcClient)
-	c.fd = fd
-	c.r.fd = fd
-	c.s.fd = fd
-	c.service = make(map[string]srpcService)
-	c.pending = make(map[uint32]*srpc)
-
-	// service discovery request
-	m := &msg{
-		isRequest: 1,
-		template:  []interface{}{[]byte(nil)},
-		size:      []int{4000}, // max size to accept for returned byte slice
-	}
-	if err := m.pack(); err != nil {
-		return nil, errors.New("Native Client SRPC service_discovery: preparing request: " + err.Error())
-	}
-	c.s.send(m)
-	m, err := c.r.recv()
-	if err != nil {
-		return nil, err
-	}
-	m.unpack()
-	if m.status != uint32(srpcOK) {
-		return nil, errors.New("Native Client SRPC service_discovery: " + srpcErrno(m.status).Error())
-	}
-	list := m.value[0].([]byte)
-	var n uint32
-	for len(list) > 0 {
-		var line []byte
-		i := byteIndex(list, '\n')
-		if i < 0 {
-			line, list = list, nil
-		} else {
-			line, list = list[:i], list[i+1:]
-		}
-		i = byteIndex(line, ':')
-		if i >= 0 {
-			c.service[string(line)] = srpcService{n, string(line[i+1:])}
-		}
-		n++
-	}
-
-	return c, nil
-}
-
-func byteIndex(b []byte, c byte) int {
-	for i, bi := range b {
-		if bi == c {
-			return i
-		}
-	}
-	return -1
-}
-
-var yourTurn srpc
-
-func (c *srpcClient) wait(r *srpc) {
-	var rx *srpc
-	for rx = range r.Done {
-		if rx != &yourTurn {
-			break
-		}
-		c.input()
-	}
-	return
-}
-
-func (c *srpcClient) input() {
-	// read message
-	m, err := c.r.recv()
-	if err != nil {
-		println("Native Client SRPC receive error:", err.Error())
-		return
-	}
-	if m.unpack(); m.status != uint32(srpcOK) {
-		println("Native Client SRPC receive error: invalid message: ", srpcErrno(m.status).Error())
-		return
-	}
-
-	// deliver to intended recipient
-	c.mu.Lock()
-	rpc, ok := c.pending[m.id]
-	if ok {
-		delete(c.pending, m.id)
-	}
-
-	// wake a new muxer if there are more RPCs to read
-	c.muxer = false
-	for _, rpc := range c.pending {
-		c.muxer = true
-		rpc.Done <- &yourTurn
-		break
-	}
-	c.mu.Unlock()
-	if !ok {
-		println("Native Client: unexpected response for ID", m.id)
-		return
-	}
-	rpc.Ret = m.value
-	rpc.Done <- rpc
-}
-
-// Wait blocks until the RPC has finished.
-func (r *srpc) Wait() {
-	r.c.wait(r)
-}
-
-// Start issues an RPC request for method name with the given arguments.
-// The RPC r must not be in use for another pending request.
-// To wait for the RPC to finish, receive from r.Done and then
-// inspect r.Ret and r.Errno.
-func (r *srpc) Start(name string, arg []interface{}) {
-	r.Err = nil
-	r.c.mu.Lock()
-	srv, ok := r.c.service[name]
-	if !ok {
-		r.c.mu.Unlock()
-		r.Err = srpcErrBadRPCNumber
-		r.Done <- r
-		return
-	}
-	r.c.pending[r.id] = r
-	if !r.c.muxer {
-		r.c.muxer = true
-		r.Done <- &yourTurn
-	}
-	r.c.mu.Unlock()
-
-	var m msg
-	m.id = r.id
-	m.isRequest = 1
-	m.rpc = srv.num
-	m.value = arg
-
-	// Fill in the return values and sizes to generate
-	// the right type chars.  We'll take most any size.
-
-	// Skip over input arguments.
-	// We could check them against arg, but the server
-	// will do that anyway.
-	i := 0
-	for srv.fmt[i] != ':' {
-		i++
-	}
-	format := srv.fmt[i+1:]
-
-	// Now the return prototypes.
-	m.template = make([]interface{}, len(format))
-	m.size = make([]int, len(format))
-	for i := 0; i < len(format); i++ {
-		switch format[i] {
-		default:
-			println("Native Client SRPC: unexpected service type " + string(format[i]))
-			r.Err = srpcErrBadRPCNumber
-			r.Done <- r
-			return
-		case 'b':
-			m.template[i] = false
-		case 'C':
-			m.template[i] = []byte(nil)
-			m.size[i] = 1 << 30
-		case 'd':
-			m.template[i] = float64(0)
-		case 'D':
-			m.template[i] = []float64(nil)
-			m.size[i] = 1 << 30
-		case 'h':
-			m.template[i] = int(-1)
-		case 'i':
-			m.template[i] = int32(0)
-		case 'I':
-			m.template[i] = []int32(nil)
-			m.size[i] = 1 << 30
-		case 's':
-			m.template[i] = ""
-			m.size[i] = 1 << 30
-		}
-	}
-
-	if err := m.pack(); err != nil {
-		r.Err = errors.New("Native Client RPC Start " + name + ": preparing request: " + err.Error())
-		r.Done <- r
-		return
-	}
-
-	r.c.outMu.Lock()
-	r.c.s.send(&m)
-	r.c.outMu.Unlock()
-}
-
-// Call is a convenience wrapper that starts the RPC request,
-// waits for it to finish, and then returns the results.
-// Its implementation is:
-//
-//	r.Start(name, arg)
-//	r.Wait()
-//	return r.Ret, r.Errno
-//
-func (c *srpcClient) Call(name string, arg ...interface{}) (ret []interface{}, err error) {
-	r := c.NewRPC(nil)
-	r.Start(name, arg)
-	r.Wait()
-	return r.Ret, r.Err
-}
-
-// NewRPC creates a new RPC on the client connection.
-func (c *srpcClient) NewRPC(done chan *srpc) *srpc {
-	if done == nil {
-		done = make(chan *srpc, 1)
-	}
-	c.mu.Lock()
-	id := c.idGen
-	c.idGen++
-	c.mu.Unlock()
-	return &srpc{Done: done, c: c, id: id}
-}
-
-// The current protocol number.
-// Kind of useless, since there have been backwards-incompatible changes
-// to the wire protocol that did not update the protocol number.
-// At this point it's really just a sanity check.
-const protocol = 0xc0da0002
-
-// An srpcErrno is an SRPC status code.
-type srpcErrno uint32
-
-const (
-	srpcOK srpcErrno = 256 + iota
-	srpcErrBreak
-	srpcErrMessageTruncated
-	srpcErrNoMemory
-	srpcErrProtocolMismatch
-	srpcErrBadRPCNumber
-	srpcErrBadArgType
-	srpcErrTooFewArgs
-	srpcErrTooManyArgs
-	srpcErrInArgTypeMismatch
-	srpcErrOutArgTypeMismatch
-	srpcErrInternalError
-	srpcErrAppError
-)
-
-var srpcErrstr = [...]string{
-	srpcOK - srpcOK:                    "ok",
-	srpcErrBreak - srpcOK:              "break",
-	srpcErrMessageTruncated - srpcOK:   "message truncated",
-	srpcErrNoMemory - srpcOK:           "out of memory",
-	srpcErrProtocolMismatch - srpcOK:   "protocol mismatch",
-	srpcErrBadRPCNumber - srpcOK:       "invalid RPC method number",
-	srpcErrBadArgType - srpcOK:         "unexpected argument type",
-	srpcErrTooFewArgs - srpcOK:         "too few arguments",
-	srpcErrTooManyArgs - srpcOK:        "too many arguments",
-	srpcErrInArgTypeMismatch - srpcOK:  "input argument type mismatch",
-	srpcErrOutArgTypeMismatch - srpcOK: "output argument type mismatch",
-	srpcErrInternalError - srpcOK:      "internal error",
-	srpcErrAppError - srpcOK:           "application error",
-}
-
-func (e srpcErrno) Error() string {
-	if e < srpcOK || int(e-srpcOK) >= len(srpcErrstr) {
-		return "srpcErrno(" + itoa(int(e)) + ")"
-	}
-	return srpcErrstr[e-srpcOK]
-}
-
-// A msgHdr is the data argument to the imc_recvmsg
-// and imc_sendmsg system calls.
-type msgHdr struct {
-	iov   *iov
-	niov  int32
-	desc  *int32
-	ndesc int32
-	flags uint32
-}
-
-// A single region for I/O.
-type iov struct {
-	base *byte
-	len  int32
-}
-
-const maxMsgSize = 1<<16 - 4*4
-
-// A msgReceiver receives messages from a file descriptor.
-type msgReceiver struct {
-	fd   int
-	data [maxMsgSize]byte
-	desc [8]int32
-	hdr  msgHdr
-	iov  iov
-}
-
-func (r *msgReceiver) recv() (*msg, error) {
-	// Init pointers to buffers where syscall recvmsg can write.
-	r.iov.base = &r.data[0]
-	r.iov.len = int32(len(r.data))
-	r.hdr.iov = &r.iov
-	r.hdr.niov = 1
-	r.hdr.desc = &r.desc[0]
-	r.hdr.ndesc = int32(len(r.desc))
-	n, _, e := Syscall(sys_imc_recvmsg, uintptr(r.fd), uintptr(unsafe.Pointer(&r.hdr)), 0)
-	if e != 0 {
-		println("Native Client imc_recvmsg: ", e.Error())
-		return nil, e
-	}
-
-	// Make a copy of the data so that the next recvmsg doesn't
-	// smash it.  The system call did not update r.iov.len.  Instead it
-	// returned the total byte count as n.
-	m := new(msg)
-	m.data = make([]byte, n)
-	copy(m.data, r.data[0:])
-
-	// Make a copy of the desc too.
-	// The system call *did* update r.hdr.ndesc.
-	if r.hdr.ndesc > 0 {
-		m.desc = make([]int32, r.hdr.ndesc)
-		copy(m.desc, r.desc[:])
-	}
-
-	return m, nil
-}
-
-// A msgSender sends messages on a file descriptor.
-type msgSender struct {
-	fd  int
-	hdr msgHdr
-	iov iov
-}
-
-func (s *msgSender) send(m *msg) error {
-	if len(m.data) > 0 {
-		s.iov.base = &m.data[0]
-	}
-	s.iov.len = int32(len(m.data))
-	s.hdr.iov = &s.iov
-	s.hdr.niov = 1
-	s.hdr.desc = nil
-	s.hdr.ndesc = 0
-	_, _, e := Syscall(sys_imc_sendmsg, uintptr(s.fd), uintptr(unsafe.Pointer(&s.hdr)), 0)
-	if e != 0 {
-		println("Native Client imc_sendmsg: ", e.Error())
-		return e
-	}
-	return nil
-}
-
-// A msg is the Go representation of an SRPC message.
-type msg struct {
-	data []byte  // message data
-	desc []int32 // message file descriptors
-
-	// parsed version of message
-	id        uint32
-	isRequest uint32
-	rpc       uint32
-	status    uint32
-	value     []interface{}
-	template  []interface{}
-	size      []int
-	format    string
-	broken    bool
-}
-
-// reading from a msg
-
-func (m *msg) uint32() uint32 {
-	if m.broken {
-		return 0
-	}
-	if len(m.data) < 4 {
-		m.broken = true
-		return 0
-	}
-	b := m.data[:4]
-	x := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
-	m.data = m.data[4:]
-	return x
-}
-
-func (m *msg) uint64() uint64 {
-	x := uint64(m.uint32()) | uint64(m.uint32())<<32
-	if m.broken {
-		return 0
-	}
-	return x
-}
-
-func (m *msg) bytes(n int) []byte {
-	if m.broken {
-		return nil
-	}
-	if len(m.data) < n {
-		m.broken = true
-		return nil
-	}
-	x := m.data[0:n]
-	m.data = m.data[n:]
-	return x
-}
-
-// writing to a msg
-
-func (m *msg) wuint32(x uint32) {
-	m.data = append(m.data, byte(x), byte(x>>8), byte(x>>16), byte(x>>24))
-}
-
-func (m *msg) wuint64(x uint64) {
-	lo := uint32(x)
-	hi := uint32(x >> 32)
-	m.data = append(m.data, byte(lo), byte(lo>>8), byte(lo>>16), byte(lo>>24), byte(hi), byte(hi>>8), byte(hi>>16), byte(hi>>24))
-}
-
-func (m *msg) wbytes(p []byte) {
-	m.data = append(m.data, p...)
-}
-
-func (m *msg) wstring(s string) {
-	m.data = append(m.data, s...)
-}
-
-// Parsing of RPC messages.
-//
-// Each message begins with
-//	total_size uint32
-//	total_descs uint32
-//	fragment_size uint32
-//	fragment_descs uint32
-//
-// If fragment_size < total_size or fragment_descs < total_descs, the actual
-// message is broken up in multiple messages; follow-up messages omit
-// the "total" fields and begin with the "fragment" fields.
-// We do not support putting fragmented messages back together.
-// To do this we would need to change the message receiver.
-//
-// After that size information, the message header follows:
-//	protocol uint32
-//	requestID uint32
-//	isRequest uint32
-//	rpcNumber uint32
-//	status uint32
-//	numValue uint32
-//	numTemplate uint32
-//
-// After the header come numTemplate fixed-size arguments,
-// numValue fixed-size arguments, and then the variable-sized
-// part of the values. The templates describe the expected results
-// and have no associated variable sized data in the request.
-//
-// Each fixed-size argument has the form:
-//	tag uint32 // really a char, like 'b' or 'C'
-//	pad uint32 // unused
-//	val1 uint32
-//	val2 uint32
-//
-// The tags are:
-//	'b':	bool; val1 == 0 or 1
-//	'C':	[]byte; val1 == len, data in variable-sized section
-//	'd':	float64; (val1, val2) is data
-//	'D':	[]float64; val1 == len, data in variable-sized section
-//	'h':	int; val1 == file descriptor
-//	'i':	int32; descriptor in next entry in m.desc
-//	'I':	[]int; val1 == len, data in variable-sized section
-//	's':	string; val1 == len, data in variable-sized section
-//
-
-func (m *msg) pack() error {
-	m.data = m.data[:0]
-	m.desc = m.desc[:0]
-
-	// sizes, to fill in later
-	m.wuint32(0)
-	m.wuint32(0)
-	m.wuint32(0)
-	m.wuint32(0)
-
-	// message header
-	m.wuint32(protocol)
-	m.wuint32(m.id)
-	m.wuint32(m.isRequest)
-	m.wuint32(m.rpc)
-	m.wuint32(m.status)
-	m.wuint32(uint32(len(m.value)))
-	m.wuint32(uint32(len(m.template)))
-
-	// fixed-size templates
-	for i, x := range m.template {
-		var tag, val1, val2 uint32
-		switch x.(type) {
-		default:
-			return errors.New("unexpected template type")
-		case bool:
-			tag = 'b'
-		case []byte:
-			tag = 'C'
-			val1 = uint32(m.size[i])
-		case float64:
-			tag = 'd'
-		case []float64:
-			tag = 'D'
-			val1 = uint32(m.size[i])
-		case int:
-			tag = 'h'
-		case int32:
-			tag = 'i'
-		case []int32:
-			tag = 'I'
-			val1 = uint32(m.size[i])
-		case string:
-			tag = 's'
-			val1 = uint32(m.size[i])
-		}
-		m.wuint32(tag)
-		m.wuint32(0)
-		m.wuint32(val1)
-		m.wuint32(val2)
-	}
-
-	// fixed-size values
-	for _, x := range m.value {
-		var tag, val1, val2 uint32
-		switch x := x.(type) {
-		default:
-			return errors.New("unexpected value type")
-		case bool:
-			tag = 'b'
-			if x {
-				val1 = 1
-			}
-		case []byte:
-			tag = 'C'
-			val1 = uint32(len(x))
-		case float64:
-			tag = 'd'
-			v := float64bits(x)
-			val1 = uint32(v)
-			val2 = uint32(v >> 32)
-		case []float64:
-			tag = 'D'
-			val1 = uint32(len(x))
-		case int32:
-			tag = 'i'
-			m.desc = append(m.desc, x)
-		case []int32:
-			tag = 'I'
-			val1 = uint32(len(x))
-		case string:
-			tag = 's'
-			val1 = uint32(len(x) + 1)
-		}
-		m.wuint32(tag)
-		m.wuint32(0)
-		m.wuint32(val1)
-		m.wuint32(val2)
-	}
-
-	// variable-length data for values
-	for _, x := range m.value {
-		switch x := x.(type) {
-		case []byte:
-			m.wbytes(x)
-		case []float64:
-			for _, f := range x {
-				m.wuint64(float64bits(f))
-			}
-		case []int32:
-			for _, j := range x {
-				m.wuint32(uint32(j))
-			}
-		case string:
-			m.wstring(x)
-			m.wstring("\x00")
-		}
-	}
-
-	// fill in sizes
-	data := m.data
-	m.data = m.data[:0]
-	m.wuint32(uint32(len(data)))
-	m.wuint32(uint32(len(m.desc)))
-	m.wuint32(uint32(len(data)))
-	m.wuint32(uint32(len(m.desc)))
-	m.data = data
-
-	return nil
-}
-
-func (m *msg) unpack() error {
-	totalSize := m.uint32()
-	totalDesc := m.uint32()
-	fragSize := m.uint32()
-	fragDesc := m.uint32()
-	if totalSize != fragSize || totalDesc != fragDesc {
-		return errors.New("Native Client: fragmented RPC messages not supported")
-	}
-	if m.uint32() != protocol {
-		return errors.New("Native Client: RPC protocol mismatch")
-	}
-
-	// message header
-	m.id = m.uint32()
-	m.isRequest = m.uint32()
-	m.rpc = m.uint32()
-	m.status = m.uint32()
-	m.value = make([]interface{}, m.uint32())
-	m.template = make([]interface{}, m.uint32())
-	m.size = make([]int, len(m.template))
-	if m.broken {
-		return errors.New("Native Client: malformed message")
-	}
-
-	// fixed-size templates
-	for i := range m.template {
-		tag := m.uint32()
-		m.uint32() // padding
-		val1 := m.uint32()
-		m.uint32() // val2
-		switch tag {
-		default:
-			return errors.New("Native Client: unexpected template type " + string(rune(tag)))
-		case 'b':
-			m.template[i] = false
-		case 'C':
-			m.template[i] = []byte(nil)
-			m.size[i] = int(val1)
-		case 'd':
-			m.template[i] = float64(0)
-		case 'D':
-			m.template[i] = []float64(nil)
-			m.size[i] = int(val1)
-		case 'i':
-			m.template[i] = int32(0)
-		case 'I':
-			m.template[i] = []int32(nil)
-			m.size[i] = int(val1)
-		case 'h':
-			m.template[i] = int(0)
-		case 's':
-			m.template[i] = ""
-			m.size[i] = int(val1)
-		}
-	}
-
-	// fixed-size values
-	var (
-		strsize []uint32
-		d       int
-	)
-	for i := range m.value {
-		tag := m.uint32()
-		m.uint32() // padding
-		val1 := m.uint32()
-		val2 := m.uint32()
-		switch tag {
-		default:
-			return errors.New("Native Client: unexpected value type " + string(rune(tag)))
-		case 'b':
-			m.value[i] = val1 > 0
-		case 'C':
-			m.value[i] = []byte(nil)
-			strsize = append(strsize, val1)
-		case 'd':
-			m.value[i] = float64frombits(uint64(val1) | uint64(val2)<<32)
-		case 'D':
-			m.value[i] = make([]float64, val1)
-		case 'i':
-			m.value[i] = int32(val1)
-		case 'I':
-			m.value[i] = make([]int32, val1)
-		case 'h':
-			m.value[i] = int(m.desc[d])
-			d++
-		case 's':
-			m.value[i] = ""
-			strsize = append(strsize, val1)
-		}
-	}
-
-	// variable-sized parts of values
-	for i, x := range m.value {
-		switch x := x.(type) {
-		case []byte:
-			m.value[i] = m.bytes(int(strsize[0]))
-			strsize = strsize[1:]
-		case []float64:
-			for i := range x {
-				x[i] = float64frombits(m.uint64())
-			}
-		case []int32:
-			for i := range x {
-				x[i] = int32(m.uint32())
-			}
-		case string:
-			m.value[i] = string(m.bytes(int(strsize[0])))
-			strsize = strsize[1:]
-		}
-	}
-
-	if len(m.data) > 0 {
-		return errors.New("Native Client: junk at end of message")
-	}
-	return nil
-}
-
-func float64bits(x float64) uint64 {
-	return *(*uint64)(unsafe.Pointer(&x))
-}
-
-func float64frombits(x uint64) float64 {
-	return *(*float64)(unsafe.Pointer(&x))
-}
-
-// At startup, connect to the name service.
-var nsClient = nsConnect()
-
-func nsConnect() *srpcClient {
-	var ns int32 = -1
-	_, _, errno := Syscall(sys_nameservice, uintptr(unsafe.Pointer(&ns)), 0, 0)
-	if errno != 0 {
-		println("Native Client nameservice:", errno.Error())
-		return nil
-	}
-
-	sock, _, errno := Syscall(sys_imc_connect, uintptr(ns), 0, 0)
-	if errno != 0 {
-		println("Native Client nameservice connect:", errno.Error())
-		return nil
-	}
-
-	c, err := newClient(int(sock))
-	if err != nil {
-		println("Native Client nameservice init:", err.Error())
-		return nil
-	}
-
-	return c
-}
-
-const (
-	nsSuccess               = 0
-	nsNameNotFound          = 1
-	nsDuplicateName         = 2
-	nsInsufficientResources = 3
-	nsPermissionDenied      = 4
-	nsInvalidArgument       = 5
-)
-
-func openNamedService(name string, mode int32) (fd int, err error) {
-	if nsClient == nil {
-		return 0, errors.New("no name service")
-	}
-	ret, err := nsClient.Call("lookup:si:ih", name, int32(mode))
-	if err != nil {
-		return 0, err
-	}
-	status := ret[0].(int32)
-	fd = ret[1].(int)
-	switch status {
-	case nsSuccess:
-		// ok
-	case nsNameNotFound:
-		return -1, ENOENT
-	case nsDuplicateName:
-		return -1, EEXIST
-	case nsInsufficientResources:
-		return -1, EWOULDBLOCK
-	case nsPermissionDenied:
-		return -1, EPERM
-	case nsInvalidArgument:
-		return -1, EINVAL
-	default:
-		return -1, EINVAL
-	}
-	return fd, nil
-}

unix/syscall_nacl.go

@@ -1,311 +0,0 @@
-// Copyright 2013 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.
-
-package unix
-
-import (
-	"sync"
-	"unsafe"
-)
-
-//sys	naclClose(fd int) (err error) = sys_close
-//sys	Exit(code int) (err error)
-//sys	naclFstat(fd int, stat *Stat_t) (err error) = sys_fstat
-//sys	naclRead(fd int, b []byte) (n int, err error) = sys_read
-//sys	naclSeek(fd int, off *int64, whence int) (err error) = sys_lseek
-
-const direntSize = 8 + 8 + 2 + 256
-
-// native_client/src/trusted/service_runtime/include/sys/dirent.h
-type Dirent struct {
-	Ino    int64
-	Off    int64
-	Reclen uint16
-	Name   [256]byte
-}
-
-func ParseDirent(buf []byte, max int, names []string) (consumed int, count int, newnames []string) {
-	origlen := len(buf)
-	count = 0
-	for max != 0 && len(buf) > 0 {
-		dirent := (*Dirent)(unsafe.Pointer(&buf[0]))
-		buf = buf[dirent.Reclen:]
-		if dirent.Ino == 0 { // File absent in directory.
-			continue
-		}
-		bytes := (*[512 + PathMax]byte)(unsafe.Pointer(&dirent.Name[0]))
-		var name = string(bytes[0:clen(bytes[:])])
-		if name == "." || name == ".." { // Useless names
-			continue
-		}
-		max--
-		count++
-		names = append(names, name)
-	}
-	return origlen - len(buf), count, names
-}
-
-func clen(n []byte) int {
-	for i := 0; i < len(n); i++ {
-		if n[i] == 0 {
-			return i
-		}
-	}
-	return len(n)
-}
-
-const PathMax = 256
-
-// An Errno is an unsigned number describing an error condition.
-// It implements the error interface.  The zero Errno is by convention
-// a non-error, so code to convert from Errno to error should use:
-//	err = nil
-//	if errno != 0 {
-//		err = errno
-//	}
-type Errno uintptr
-
-func (e Errno) Error() string {
-	if 0 <= int(e) && int(e) < len(errorstr) {
-		s := errorstr[e]
-		if s != "" {
-			return s
-		}
-	}
-	return "errno " + itoa(int(e))
-}
-
-func (e Errno) Temporary() bool {
-	return e == EINTR || e == EMFILE || e.Timeout()
-}
-
-func (e Errno) Timeout() bool {
-	return e == EAGAIN || e == EWOULDBLOCK || e == ETIMEDOUT
-}
-
-// A Signal is a number describing a process signal.
-// It implements the os.Signal interface.
-type Signal int
-
-const (
-	_ Signal = iota
-	SIGCHLD
-	SIGINT
-	SIGKILL
-	SIGTRAP
-	SIGQUIT
-)
-
-func (s Signal) Signal() {}
-
-func (s Signal) String() string {
-	if 0 <= s && int(s) < len(signals) {
-		str := signals[s]
-		if str != "" {
-			return str
-		}
-	}
-	return "signal " + itoa(int(s))
-}
-
-var signals = [...]string{}
-
-// File system
-
-const (
-	Stdin  = 0
-	Stdout = 1
-	Stderr = 2
-)
-
-// native_client/src/trusted/service_runtime/include/sys/fcntl.h
-const (
-	O_RDONLY  = 0
-	O_WRONLY  = 1
-	O_RDWR    = 2
-	O_ACCMODE = 3
-
-	O_CREAT    = 0100
-	O_CREATE   = O_CREAT // for ken
-	O_TRUNC    = 01000
-	O_APPEND   = 02000
-	O_EXCL     = 0200
-	O_NONBLOCK = 04000
-	O_NDELAY   = O_NONBLOCK
-	O_SYNC     = 010000
-	O_FSYNC    = O_SYNC
-	O_ASYNC    = 020000
-
-	O_CLOEXEC = 0
-
-	FD_CLOEXEC = 1
-)
-
-// native_client/src/trusted/service_runtime/include/sys/fcntl.h
-const (
-	F_DUPFD   = 0
-	F_GETFD   = 1
-	F_SETFD   = 2
-	F_GETFL   = 3
-	F_SETFL   = 4
-	F_GETOWN  = 5
-	F_SETOWN  = 6
-	F_GETLK   = 7
-	F_SETLK   = 8
-	F_SETLKW  = 9
-	F_RGETLK  = 10
-	F_RSETLK  = 11
-	F_CNVT    = 12
-	F_RSETLKW = 13
-
-	F_RDLCK   = 1
-	F_WRLCK   = 2
-	F_UNLCK   = 3
-	F_UNLKSYS = 4
-)
-
-// native_client/src/trusted/service_runtime/include/bits/stat.h
-const (
-	S_IFMT        = 0000370000
-	S_IFSHM_SYSV  = 0000300000
-	S_IFSEMA      = 0000270000
-	S_IFCOND      = 0000260000
-	S_IFMUTEX     = 0000250000
-	S_IFSHM       = 0000240000
-	S_IFBOUNDSOCK = 0000230000
-	S_IFSOCKADDR  = 0000220000
-	S_IFDSOCK     = 0000210000
-
-	S_IFSOCK = 0000140000
-	S_IFLNK  = 0000120000
-	S_IFREG  = 0000100000
-	S_IFBLK  = 0000060000
-	S_IFDIR  = 0000040000
-	S_IFCHR  = 0000020000
-	S_IFIFO  = 0000010000
-
-	S_UNSUP = 0000370000
-
-	S_ISUID = 0004000
-	S_ISGID = 0002000
-	S_ISVTX = 0001000
-
-	S_IREAD  = 0400
-	S_IWRITE = 0200
-	S_IEXEC  = 0100
-
-	S_IRWXU = 0700
-	S_IRUSR = 0400
-	S_IWUSR = 0200
-	S_IXUSR = 0100
-
-	S_IRWXG = 070
-	S_IRGRP = 040
-	S_IWGRP = 020
-	S_IXGRP = 010
-
-	S_IRWXO = 07
-	S_IROTH = 04
-	S_IWOTH = 02
-	S_IXOTH = 01
-)
-
-// native_client/src/trusted/service_runtime/include/sys/stat.h
-// native_client/src/trusted/service_runtime/include/machine/_types.h
-type Stat_t struct {
-	Dev       int64
-	Ino       uint64
-	Mode      uint32
-	Nlink     uint32
-	Uid       uint32
-	Gid       uint32
-	Rdev      int64
-	Size      int64
-	Blksize   int32
-	Blocks    int32
-	Atime     int64
-	AtimeNsec int64
-	Mtime     int64
-	MtimeNsec int64
-	Ctime     int64
-	CtimeNsec int64
-}
-
-// Processes
-// Not supported on NaCl - just enough for package os.
-
-var ForkLock sync.RWMutex
-
-type WaitStatus uint32
-
-func (w WaitStatus) Exited() bool       { return false }
-func (w WaitStatus) ExitStatus() int    { return 0 }
-func (w WaitStatus) Signaled() bool     { return false }
-func (w WaitStatus) Signal() Signal     { return 0 }
-func (w WaitStatus) CoreDump() bool     { return false }
-func (w WaitStatus) Stopped() bool      { return false }
-func (w WaitStatus) Continued() bool    { return false }
-func (w WaitStatus) StopSignal() Signal { return 0 }
-func (w WaitStatus) TrapCause() int     { return 0 }
-
-// XXX made up
-type Rusage struct {
-	Utime Timeval
-	Stime Timeval
-}
-
-// XXX made up
-type ProcAttr struct {
-	Dir   string
-	Env   []string
-	Files []uintptr
-	Sys   *SysProcAttr
-}
-
-type SysProcAttr struct {
-}
-
-// System
-
-func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
-func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) { return 0, 0, ENOSYS }
-func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)           { return 0, 0, ENOSYS }
-func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) {
-	return 0, 0, ENOSYS
-}
-
-func Sysctl(key string) (string, error) {
-	if key == "kern.hostname" {
-		return "naclbox", nil
-	}
-	return "", ENOSYS
-}
-
-// Unimplemented Unix midden heap.
-
-const ImplementsGetwd = false
-
-func Getwd() (wd string, err error)     { return "", ENOSYS }
-func Getegid() int                      { return 1 }
-func Geteuid() int                      { return 1 }
-func Getgid() int                       { return 1 }
-func Getgroups() ([]int, error)         { return []int{1}, nil }
-func Getpagesize() int                  { return 65536 }
-func Getppid() int                      { return 2 }
-func Getpid() int                       { return 3 }
-func Getuid() int                       { return 1 }
-func Kill(pid int, signum Signal) error { return ENOSYS }
-func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
-	return 0, ENOSYS
-}
-func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle uintptr, err error) {
-	return 0, 0, ENOSYS
-}
-func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {
-	return 0, ENOSYS
-}
-func RouteRIB(facility, param int) ([]byte, error)                { return nil, ENOSYS }
-func ParseRoutingMessage(b []byte) ([]RoutingMessage, error)      { return nil, ENOSYS }
-func ParseRoutingSockaddr(msg RoutingMessage) ([]Sockaddr, error) { return nil, ENOSYS }
-func SysctlUint32(name string) (value uint32, err error)          { return 0, ENOSYS }

unix/syscall_nacl_386.go

@@ -1,32 +0,0 @@
-// Copyright 2013 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.
-
-package unix
-
-type Timespec struct {
-	Sec  int64
-	Nsec int32
-}
-
-type Timeval struct {
-	Sec  int64
-	Usec int32
-}
-
-func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
-
-func NsecToTimespec(nsec int64) (ts Timespec) {
-	ts.Sec = int64(nsec / 1e9)
-	ts.Nsec = int32(nsec % 1e9)
-	return
-}
-
-func TimevalToNsec(tv Timeval) int64 { return int64(tv.Sec)*1e9 + int64(tv.Usec)*1e3 }
-
-func NsecToTimeval(nsec int64) (tv Timeval) {
-	nsec += 999 // round up to microsecond
-	tv.Usec = int32(nsec % 1e9 / 1e3)
-	tv.Sec = int64(nsec / 1e9)
-	return
-}

unix/syscall_nacl_amd64p32.go

@@ -1,32 +0,0 @@
-// Copyright 2013 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.
-
-package unix
-
-type Timespec struct {
-	Sec  int64
-	Nsec int32
-}
-
-type Timeval struct {
-	Sec  int64
-	Usec int32
-}
-
-func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
-
-func NsecToTimespec(nsec int64) (ts Timespec) {
-	ts.Sec = int64(nsec / 1e9)
-	ts.Nsec = int32(nsec % 1e9)
-	return
-}
-
-func TimevalToNsec(tv Timeval) int64 { return int64(tv.Sec)*1e9 + int64(tv.Usec)*1e3 }
-
-func NsecToTimeval(nsec int64) (tv Timeval) {
-	nsec += 999 // round up to microsecond
-	tv.Usec = int32(nsec % 1e9 / 1e3)
-	tv.Sec = int64(nsec / 1e9)
-	return
-}

unix/syscall_nacl_arm.go

@@ -1,32 +0,0 @@
-// Copyright 2014 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.
-
-package unix
-
-type Timespec struct {
-	Sec  int64
-	Nsec int32
-}
-
-type Timeval struct {
-	Sec  int64
-	Usec int32
-}
-
-func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
-
-func NsecToTimespec(nsec int64) (ts Timespec) {
-	ts.Sec = int64(nsec / 1e9)
-	ts.Nsec = int32(nsec % 1e9)
-	return
-}
-
-func TimevalToNsec(tv Timeval) int64 { return int64(tv.Sec)*1e9 + int64(tv.Usec)*1e3 }
-
-func NsecToTimeval(nsec int64) (tv Timeval) {
-	nsec += 999 // round up to microsecond
-	tv.Usec = int32(nsec % 1e9 / 1e3)
-	tv.Sec = int64(nsec / 1e9)
-	return
-}

unix/tables_nacl.go

@@ -1,324 +0,0 @@
-// Copyright 2013 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.
-
-package unix
-
-// TODO: generate with runtime/mknacl.sh, allow override with IRT.
-const (
-	sys_null                 = 1
-	sys_nameservice          = 2
-	sys_dup                  = 8
-	sys_dup2                 = 9
-	sys_open                 = 10
-	sys_close                = 11
-	sys_read                 = 12
-	sys_write                = 13
-	sys_lseek                = 14
-	sys_ioctl                = 15
-	sys_stat                 = 16
-	sys_fstat                = 17
-	sys_chmod                = 18
-	sys_brk                  = 20
-	sys_mmap                 = 21
-	sys_munmap               = 22
-	sys_getdents             = 23
-	sys_mprotect             = 24
-	sys_list_mappings        = 25
-	sys_exit                 = 30
-	sys_getpid               = 31
-	sys_sched_yield          = 32
-	sys_sysconf              = 33
-	sys_gettimeofday         = 40
-	sys_clock                = 41
-	sys_nanosleep            = 42
-	sys_clock_getres         = 43
-	sys_clock_gettime        = 44
-	sys_mkdir                = 45
-	sys_rmdir                = 46
-	sys_chdir                = 47
-	sys_getcwd               = 48
-	sys_unlink               = 49
-	sys_imc_makeboundsock    = 60
-	sys_imc_accept           = 61
-	sys_imc_connect          = 62
-	sys_imc_sendmsg          = 63
-	sys_imc_recvmsg          = 64
-	sys_imc_mem_obj_create   = 65
-	sys_imc_socketpair       = 66
-	sys_mutex_create         = 70
-	sys_mutex_lock           = 71
-	sys_mutex_trylock        = 72
-	sys_mutex_unlock         = 73
-	sys_cond_create          = 74
-	sys_cond_wait            = 75
-	sys_cond_signal          = 76
-	sys_cond_broadcast       = 77
-	sys_cond_timed_wait_abs  = 79
-	sys_thread_create        = 80
-	sys_thread_exit          = 81
-	sys_tls_init             = 82
-	sys_thread_nice          = 83
-	sys_tls_get              = 84
-	sys_second_tls_set       = 85
-	sys_second_tls_get       = 86
-	sys_exception_handler    = 87
-	sys_exception_stack      = 88
-	sys_exception_clear_flag = 89
-	sys_sem_create           = 100
-	sys_sem_wait             = 101
-	sys_sem_post             = 102
-	sys_sem_get_value        = 103
-	sys_dyncode_create       = 104
-	sys_dyncode_modify       = 105
-	sys_dyncode_delete       = 106
-	sys_test_infoleak        = 109
-	sys_test_crash           = 110
-	sys_test_syscall_1       = 111
-	sys_test_syscall_2       = 112
-)
-
-// TODO: Auto-generate some day. (Hard-coded in binaries so not likely to change.)
-const (
-	// native_client/src/trusted/service_runtime/include/sys/errno.h
-	// The errors are mainly copied from Linux.
-	EPERM           Errno = 1       /* Operation not permitted */
-	ENOENT          Errno = 2       /* No such file or directory */
-	ESRCH           Errno = 3       /* No such process */
-	EINTR           Errno = 4       /* Interrupted system call */
-	EIO             Errno = 5       /* I/O error */
-	ENXIO           Errno = 6       /* No such device or address */
-	E2BIG           Errno = 7       /* Argument list too long */
-	ENOEXEC         Errno = 8       /* Exec format error */
-	EBADF           Errno = 9       /* Bad file number */
-	ECHILD          Errno = 10      /* No child processes */
-	EAGAIN          Errno = 11      /* Try again */
-	ENOMEM          Errno = 12      /* Out of memory */
-	EACCES          Errno = 13      /* Permission denied */
-	EFAULT          Errno = 14      /* Bad address */
-	EBUSY           Errno = 16      /* Device or resource busy */
-	EEXIST          Errno = 17      /* File exists */
-	EXDEV           Errno = 18      /* Cross-device link */
-	ENODEV          Errno = 19      /* No such device */
-	ENOTDIR         Errno = 20      /* Not a directory */
-	EISDIR          Errno = 21      /* Is a directory */
-	EINVAL          Errno = 22      /* Invalid argument */
-	ENFILE          Errno = 23      /* File table overflow */
-	EMFILE          Errno = 24      /* Too many open files */
-	ENOTTY          Errno = 25      /* Not a typewriter */
-	EFBIG           Errno = 27      /* File too large */
-	ENOSPC          Errno = 28      /* No space left on device */
-	ESPIPE          Errno = 29      /* Illegal seek */
-	EROFS           Errno = 30      /* Read-only file system */
-	EMLINK          Errno = 31      /* Too many links */
-	EPIPE           Errno = 32      /* Broken pipe */
-	ENAMETOOLONG    Errno = 36      /* File name too long */
-	ENOSYS          Errno = 38      /* Function not implemented */
-	EDQUOT          Errno = 122     /* Quota exceeded */
-	EDOM            Errno = 33      /* Math arg out of domain of func */
-	ERANGE          Errno = 34      /* Math result not representable */
-	EDEADLK         Errno = 35      /* Deadlock condition */
-	ENOLCK          Errno = 37      /* No record locks available */
-	ENOTEMPTY       Errno = 39      /* Directory not empty */
-	ELOOP           Errno = 40      /* Too many symbolic links */
-	ENOMSG          Errno = 42      /* No message of desired type */
-	EIDRM           Errno = 43      /* Identifier removed */
-	ECHRNG          Errno = 44      /* Channel number out of range */
-	EL2NSYNC        Errno = 45      /* Level 2 not synchronized */
-	EL3HLT          Errno = 46      /* Level 3 halted */
-	EL3RST          Errno = 47      /* Level 3 reset */
-	ELNRNG          Errno = 48      /* Link number out of range */
-	EUNATCH         Errno = 49      /* Protocol driver not attached */
-	ENOCSI          Errno = 50      /* No CSI structure available */
-	EL2HLT          Errno = 51      /* Level 2 halted */
-	EBADE           Errno = 52      /* Invalid exchange */
-	EBADR           Errno = 53      /* Invalid request descriptor */
-	EXFULL          Errno = 54      /* Exchange full */
-	ENOANO          Errno = 55      /* No anode */
-	EBADRQC         Errno = 56      /* Invalid request code */
-	EBADSLT         Errno = 57      /* Invalid slot */
-	EDEADLOCK       Errno = EDEADLK /* File locking deadlock error */
-	EBFONT          Errno = 59      /* Bad font file fmt */
-	ENOSTR          Errno = 60      /* Device not a stream */
-	ENODATA         Errno = 61      /* No data (for no delay io) */
-	ETIME           Errno = 62      /* Timer expired */
-	ENOSR           Errno = 63      /* Out of streams resources */
-	ENONET          Errno = 64      /* Machine is not on the network */
-	ENOPKG          Errno = 65      /* Package not installed */
-	EREMOTE         Errno = 66      /* The object is remote */
-	ENOLINK         Errno = 67      /* The link has been severed */
-	EADV            Errno = 68      /* Advertise error */
-	ESRMNT          Errno = 69      /* Srmount error */
-	ECOMM           Errno = 70      /* Communication error on send */
-	EPROTO          Errno = 71      /* Protocol error */
-	EMULTIHOP       Errno = 72      /* Multihop attempted */
-	EDOTDOT         Errno = 73      /* Cross mount point (not really error) */
-	EBADMSG         Errno = 74      /* Trying to read unreadable message */
-	EOVERFLOW       Errno = 75      /* Value too large for defined data type */
-	ENOTUNIQ        Errno = 76      /* Given log. name not unique */
-	EBADFD          Errno = 77      /* f.d. invalid for this operation */
-	EREMCHG         Errno = 78      /* Remote address changed */
-	ELIBACC         Errno = 79      /* Can't access a needed shared lib */
-	ELIBBAD         Errno = 80      /* Accessing a corrupted shared lib */
-	ELIBSCN         Errno = 81      /* .lib section in a.out corrupted */
-	ELIBMAX         Errno = 82      /* Attempting to link in too many libs */
-	ELIBEXEC        Errno = 83      /* Attempting to exec a shared library */
-	EILSEQ          Errno = 84
-	EUSERS          Errno = 87
-	ENOTSOCK        Errno = 88  /* Socket operation on non-socket */
-	EDESTADDRREQ    Errno = 89  /* Destination address required */
-	EMSGSIZE        Errno = 90  /* Message too long */
-	EPROTOTYPE      Errno = 91  /* Protocol wrong type for socket */
-	ENOPROTOOPT     Errno = 92  /* Protocol not available */
-	EPROTONOSUPPORT Errno = 93  /* Unknown protocol */
-	ESOCKTNOSUPPORT Errno = 94  /* Socket type not supported */
-	EOPNOTSUPP      Errno = 95  /* Operation not supported on transport endpoint */
-	EPFNOSUPPORT    Errno = 96  /* Protocol family not supported */
-	EAFNOSUPPORT    Errno = 97  /* Address family not supported by protocol family */
-	EADDRINUSE      Errno = 98  /* Address already in use */
-	EADDRNOTAVAIL   Errno = 99  /* Address not available */
-	ENETDOWN        Errno = 100 /* Network interface is not configured */
-	ENETUNREACH     Errno = 101 /* Network is unreachable */
-	ENETRESET       Errno = 102
-	ECONNABORTED    Errno = 103 /* Connection aborted */
-	ECONNRESET      Errno = 104 /* Connection reset by peer */
-	ENOBUFS         Errno = 105 /* No buffer space available */
-	EISCONN         Errno = 106 /* Socket is already connected */
-	ENOTCONN        Errno = 107 /* Socket is not connected */
-	ESHUTDOWN       Errno = 108 /* Can't send after socket shutdown */
-	ETOOMANYREFS    Errno = 109
-	ETIMEDOUT       Errno = 110 /* Connection timed out */
-	ECONNREFUSED    Errno = 111 /* Connection refused */
-	EHOSTDOWN       Errno = 112 /* Host is down */
-	EHOSTUNREACH    Errno = 113 /* Host is unreachable */
-	EALREADY        Errno = 114 /* Socket already connected */
-	EINPROGRESS     Errno = 115 /* Connection already in progress */
-	ESTALE          Errno = 116
-	ENOTSUP         Errno = EOPNOTSUPP /* Not supported */
-	ENOMEDIUM       Errno = 123        /* No medium (in tape drive) */
-	ECANCELED       Errno = 125        /* Operation canceled. */
-	ELBIN           Errno = 2048       /* Inode is remote (not really error) */
-	EFTYPE          Errno = 2049       /* Inappropriate file type or format */
-	ENMFILE         Errno = 2050       /* No more files */
-	EPROCLIM        Errno = 2051
-	ENOSHARE        Errno = 2052   /* No such host or network path */
-	ECASECLASH      Errno = 2053   /* Filename exists with different case */
-	EWOULDBLOCK     Errno = EAGAIN /* Operation would block */
-)
-
-// TODO: Auto-generate some day. (Hard-coded in binaries so not likely to change.)
-var errorstr = [...]string{
-	EPERM:           "Operation not permitted",
-	ENOENT:          "No such file or directory",
-	ESRCH:           "No such process",
-	EINTR:           "Interrupted system call",
-	EIO:             "I/O error",
-	ENXIO:           "No such device or address",
-	E2BIG:           "Argument list too long",
-	ENOEXEC:         "Exec format error",
-	EBADF:           "Bad file number",
-	ECHILD:          "No child processes",
-	EAGAIN:          "Try again",
-	ENOMEM:          "Out of memory",
-	EACCES:          "Permission denied",
-	EFAULT:          "Bad address",
-	EBUSY:           "Device or resource busy",
-	EEXIST:          "File exists",
-	EXDEV:           "Cross-device link",
-	ENODEV:          "No such device",
-	ENOTDIR:         "Not a directory",
-	EISDIR:          "Is a directory",
-	EINVAL:          "Invalid argument",
-	ENFILE:          "File table overflow",
-	EMFILE:          "Too many open files",
-	ENOTTY:          "Not a typewriter",
-	EFBIG:           "File too large",
-	ENOSPC:          "No space left on device",
-	ESPIPE:          "Illegal seek",
-	EROFS:           "Read-only file system",
-	EMLINK:          "Too many links",
-	EPIPE:           "Broken pipe",
-	ENAMETOOLONG:    "File name too long",
-	ENOSYS:          "not implemented on Native Client",
-	EDQUOT:          "Quota exceeded",
-	EDOM:            "Math arg out of domain of func",
-	ERANGE:          "Math result not representable",
-	EDEADLK:         "Deadlock condition",
-	ENOLCK:          "No record locks available",
-	ENOTEMPTY:       "Directory not empty",
-	ELOOP:           "Too many symbolic links",
-	ENOMSG:          "No message of desired type",
-	EIDRM:           "Identifier removed",
-	ECHRNG:          "Channel number out of range",
-	EL2NSYNC:        "Level 2 not synchronized",
-	EL3HLT:          "Level 3 halted",
-	EL3RST:          "Level 3 reset",
-	ELNRNG:          "Link number out of range",
-	EUNATCH:         "Protocol driver not attached",
-	ENOCSI:          "No CSI structure available",
-	EL2HLT:          "Level 2 halted",
-	EBADE:           "Invalid exchange",
-	EBADR:           "Invalid request descriptor",
-	EXFULL:          "Exchange full",
-	ENOANO:          "No anode",
-	EBADRQC:         "Invalid request code",
-	EBADSLT:         "Invalid slot",
-	EBFONT:          "Bad font file fmt",
-	ENOSTR:          "Device not a stream",
-	ENODATA:         "No data (for no delay io)",
-	ETIME:           "Timer expired",
-	ENOSR:           "Out of streams resources",
-	ENONET:          "Machine is not on the network",
-	ENOPKG:          "Package not installed",
-	EREMOTE:         "The object is remote",
-	ENOLINK:         "The link has been severed",
-	EADV:            "Advertise error",
-	ESRMNT:          "Srmount error",
-	ECOMM:           "Communication error on send",
-	EPROTO:          "Protocol error",
-	EMULTIHOP:       "Multihop attempted",
-	EDOTDOT:         "Cross mount point (not really error)",
-	EBADMSG:         "Trying to read unreadable message",
-	EOVERFLOW:       "Value too large for defined data type",
-	ENOTUNIQ:        "Given log. name not unique",
-	EBADFD:          "f.d. invalid for this operation",
-	EREMCHG:         "Remote address changed",
-	ELIBACC:         "Can't access a needed shared lib",
-	ELIBBAD:         "Accessing a corrupted shared lib",
-	ELIBSCN:         ".lib section in a.out corrupted",
-	ELIBMAX:         "Attempting to link in too many libs",
-	ELIBEXEC:        "Attempting to exec a shared library",
-	ENOTSOCK:        "Socket operation on non-socket",
-	EDESTADDRREQ:    "Destination address required",
-	EMSGSIZE:        "Message too long",
-	EPROTOTYPE:      "Protocol wrong type for socket",
-	ENOPROTOOPT:     "Protocol not available",
-	EPROTONOSUPPORT: "Unknown protocol",
-	ESOCKTNOSUPPORT: "Socket type not supported",
-	EOPNOTSUPP:      "Operation not supported on transport endpoint",
-	EPFNOSUPPORT:    "Protocol family not supported",
-	EAFNOSUPPORT:    "Address family not supported by protocol family",
-	EADDRINUSE:      "Address already in use",
-	EADDRNOTAVAIL:   "Address not available",
-	ENETDOWN:        "Network interface is not configured",
-	ENETUNREACH:     "Network is unreachable",
-	ECONNABORTED:    "Connection aborted",
-	ECONNRESET:      "Connection reset by peer",
-	ENOBUFS:         "No buffer space available",
-	EISCONN:         "Socket is already connected",
-	ENOTCONN:        "Socket is not connected",
-	ESHUTDOWN:       "Can't send after socket shutdown",
-	ETIMEDOUT:       "Connection timed out",
-	ECONNREFUSED:    "Connection refused",
-	EHOSTDOWN:       "Host is down",
-	EHOSTUNREACH:    "Host is unreachable",
-	EALREADY:        "Socket already connected",
-	EINPROGRESS:     "Connection already in progress",
-	ENOMEDIUM:       "No medium (in tape drive)",
-	ECANCELED:       "Operation canceled.",
-	ELBIN:           "Inode is remote (not really error)",
-	EFTYPE:          "Inappropriate file type or format",
-	ENMFILE:         "No more files",
-	ENOSHARE:        "No such host or network path",
-	ECASECLASH:      "Filename exists with different case",
-}

unix/time_nacl_386.s

@@ -1,11 +0,0 @@
-// Copyright 2013 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.
-
-#include "textflag.h"
-
-TEXT ·startTimer(SB),NOSPLIT,$0
-	JMP time·startTimer(SB)
-
-TEXT ·stopTimer(SB),NOSPLIT,$0
-	JMP time·stopTimer(SB)

unix/time_nacl_amd64p32.s

@@ -1,11 +0,0 @@
-// Copyright 2013 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.
-
-#include "textflag.h"
-
-TEXT ·startTimer(SB),NOSPLIT,$0
-	JMP time·startTimer(SB)
-
-TEXT ·stopTimer(SB),NOSPLIT,$0
-	JMP time·stopTimer(SB)

unix/time_nacl_arm.s

@@ -1,11 +0,0 @@
-// Copyright 2014 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.
-
-#include "textflag.h"
-
-TEXT ·startTimer(SB),NOSPLIT,$0
-	B time·startTimer(SB)
-
-TEXT ·stopTimer(SB),NOSPLIT,$0
-	B time·stopTimer(SB)

unix/unzip_nacl.go

@@ -1,685 +0,0 @@
-// 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.
-
-// Small in-memory unzip implementation.
-// A simplified copy of the pre-Go 1 compress/flate/inflate.go
-// and a modified copy of the zip reader in package time.
-// (The one in package time does not support decompression; this one does.)
-
-package unix
-
-const (
-	maxCodeLen = 16    // max length of Huffman code
-	maxHist    = 32768 // max history required
-	maxLit     = 286
-	maxDist    = 32
-	numCodes   = 19 // number of codes in Huffman meta-code
-)
-
-type decompressor struct {
-	in  string // compressed input
-	out []byte // uncompressed output
-	b   uint32 // input bits, at top of b
-	nb  uint
-	err bool // invalid input
-	eof bool // reached EOF
-
-	h1, h2   huffmanDecoder        // decoders for literal/length, distance
-	bits     [maxLit + maxDist]int // lengths defining Huffman codes
-	codebits [numCodes]int
-}
-
-func (f *decompressor) nextBlock() {
-	for f.nb < 1+2 {
-		if f.moreBits(); f.err {
-			return
-		}
-	}
-	f.eof = f.b&1 == 1
-	f.b >>= 1
-	typ := f.b & 3
-	f.b >>= 2
-	f.nb -= 1 + 2
-	switch typ {
-	case 0:
-		f.dataBlock()
-	case 1:
-		// compressed, fixed Huffman tables
-		f.huffmanBlock(&fixedHuffmanDecoder, nil)
-	case 2:
-		// compressed, dynamic Huffman tables
-		if f.readHuffman(); f.err {
-			break
-		}
-		f.huffmanBlock(&f.h1, &f.h2)
-	default:
-		// 3 is reserved.
-		f.err = true
-	}
-}
-
-// RFC 1951 section 3.2.7.
-// Compression with dynamic Huffman codes
-
-var codeOrder = [...]int{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}
-
-func (f *decompressor) readHuffman() {
-	// HLIT[5], HDIST[5], HCLEN[4].
-	for f.nb < 5+5+4 {
-		if f.moreBits(); f.err {
-			return
-		}
-	}
-	nlit := int(f.b&0x1F) + 257
-	f.b >>= 5
-	ndist := int(f.b&0x1F) + 1
-	f.b >>= 5
-	nclen := int(f.b&0xF) + 4
-	f.b >>= 4
-	f.nb -= 5 + 5 + 4
-
-	// (HCLEN+4)*3 bits: code lengths in the magic codeOrder order.
-	for i := 0; i < nclen; i++ {
-		for f.nb < 3 {
-			if f.moreBits(); f.err {
-				return
-			}
-		}
-		f.codebits[codeOrder[i]] = int(f.b & 0x7)
-		f.b >>= 3
-		f.nb -= 3
-	}
-	for i := nclen; i < len(codeOrder); i++ {
-		f.codebits[codeOrder[i]] = 0
-	}
-	if !f.h1.init(f.codebits[0:]) {
-		f.err = true
-		return
-	}
-
-	// HLIT + 257 code lengths, HDIST + 1 code lengths,
-	// using the code length Huffman code.
-	for i, n := 0, nlit+ndist; i < n; {
-		x := f.huffSym(&f.h1)
-		if f.err {
-			return
-		}
-		if x < 16 {
-			// Actual length.
-			f.bits[i] = x
-			i++
-			continue
-		}
-		// Repeat previous length or zero.
-		var rep int
-		var nb uint
-		var b int
-		switch x {
-		default:
-			f.err = true
-			return
-		case 16:
-			rep = 3
-			nb = 2
-			if i == 0 {
-				f.err = true
-				return
-			}
-			b = f.bits[i-1]
-		case 17:
-			rep = 3
-			nb = 3
-			b = 0
-		case 18:
-			rep = 11
-			nb = 7
-			b = 0
-		}
-		for f.nb < nb {
-			if f.moreBits(); f.err {
-				return
-			}
-		}
-		rep += int(f.b & uint32(1<<nb-1))
-		f.b >>= nb
-		f.nb -= nb
-		if i+rep > n {
-			f.err = true
-			return
-		}
-		for j := 0; j < rep; j++ {
-			f.bits[i] = b
-			i++
-		}
-	}
-
-	if !f.h1.init(f.bits[0:nlit]) || !f.h2.init(f.bits[nlit:nlit+ndist]) {
-		f.err = true
-		return
-	}
-}
-
-// Decode a single Huffman block from f.
-// hl and hd are the Huffman states for the lit/length values
-// and the distance values, respectively.  If hd == nil, using the
-// fixed distance encoding associated with fixed Huffman blocks.
-func (f *decompressor) huffmanBlock(hl, hd *huffmanDecoder) {
-	for {
-		v := f.huffSym(hl)
-		if f.err {
-			return
-		}
-		var n uint // number of bits extra
-		var length int
-		switch {
-		case v < 256:
-			f.out = append(f.out, byte(v))
-			continue
-		case v == 256:
-			// Done with huffman block; read next block.
-			return
-		// otherwise, reference to older data
-		case v < 265:
-			length = v - (257 - 3)
-			n = 0
-		case v < 269:
-			length = v*2 - (265*2 - 11)
-			n = 1
-		case v < 273:
-			length = v*4 - (269*4 - 19)
-			n = 2
-		case v < 277:
-			length = v*8 - (273*8 - 35)
-			n = 3
-		case v < 281:
-			length = v*16 - (277*16 - 67)
-			n = 4
-		case v < 285:
-			length = v*32 - (281*32 - 131)
-			n = 5
-		default:
-			length = 258
-			n = 0
-		}
-		if n > 0 {
-			for f.nb < n {
-				if f.moreBits(); f.err {
-					return
-				}
-			}
-			length += int(f.b & uint32(1<<n-1))
-			f.b >>= n
-			f.nb -= n
-		}
-
-		var dist int
-		if hd == nil {
-			for f.nb < 5 {
-				if f.moreBits(); f.err {
-					return
-				}
-			}
-			dist = int(reverseByte[(f.b&0x1F)<<3])
-			f.b >>= 5
-			f.nb -= 5
-		} else {
-			if dist = f.huffSym(hd); f.err {
-				return
-			}
-		}
-
-		switch {
-		case dist < 4:
-			dist++
-		case dist >= 30:
-			f.err = true
-			return
-		default:
-			nb := uint(dist-2) >> 1
-			// have 1 bit in bottom of dist, need nb more.
-			extra := (dist & 1) << nb
-			for f.nb < nb {
-				if f.moreBits(); f.err {
-					return
-				}
-			}
-			extra |= int(f.b & uint32(1<<nb-1))
-			f.b >>= nb
-			f.nb -= nb
-			dist = 1<<(nb+1) + 1 + extra
-		}
-
-		// Copy [-dist:-dist+length] into output.
-		// Encoding can be prescient, so no check on length.
-		if dist > len(f.out) {
-			f.err = true
-			return
-		}
-
-		p := len(f.out) - dist
-		for i := 0; i < length; i++ {
-			f.out = append(f.out, f.out[p])
-			p++
-		}
-	}
-}
-
-// Copy a single uncompressed data block from input to output.
-func (f *decompressor) dataBlock() {
-	// Uncompressed.
-	// Discard current half-byte.
-	f.nb = 0
-	f.b = 0
-
-	if len(f.in) < 4 {
-		f.err = true
-		return
-	}
-
-	buf := f.in[:4]
-	f.in = f.in[4:]
-	n := int(buf[0]) | int(buf[1])<<8
-	nn := int(buf[2]) | int(buf[3])<<8
-	if uint16(nn) != uint16(^n) {
-		f.err = true
-		return
-	}
-
-	if len(f.in) < n {
-		f.err = true
-		return
-	}
-	f.out = append(f.out, f.in[:n]...)
-	f.in = f.in[n:]
-}
-
-func (f *decompressor) moreBits() {
-	if len(f.in) == 0 {
-		f.err = true
-		return
-	}
-	c := f.in[0]
-	f.in = f.in[1:]
-	f.b |= uint32(c) << f.nb
-	f.nb += 8
-}
-
-// Read the next Huffman-encoded symbol from f according to h.
-func (f *decompressor) huffSym(h *huffmanDecoder) int {
-	for n := uint(h.min); n <= uint(h.max); n++ {
-		lim := h.limit[n]
-		if lim == -1 {
-			continue
-		}
-		for f.nb < n {
-			if f.moreBits(); f.err {
-				return 0
-			}
-		}
-		v := int(f.b & uint32(1<<n-1))
-		v <<= 16 - n
-		v = int(reverseByte[v>>8]) | int(reverseByte[v&0xFF])<<8 // reverse bits
-		if v <= lim {
-			f.b >>= n
-			f.nb -= n
-			return h.codes[v-h.base[n]]
-		}
-	}
-	f.err = true
-	return 0
-}
-
-var reverseByte = [256]byte{
-	0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
-	0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
-	0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
-	0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
-	0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
-	0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
-	0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
-	0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
-	0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
-	0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
-	0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
-	0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
-	0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
-	0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
-	0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
-	0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
-	0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
-	0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
-	0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
-	0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
-	0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
-	0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
-	0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
-	0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
-	0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
-	0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
-	0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
-	0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
-	0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
-	0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
-	0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
-	0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
-}
-
-// Hard-coded Huffman tables for DEFLATE algorithm.
-// See RFC 1951, section 3.2.6.
-var fixedHuffmanDecoder = huffmanDecoder{
-	7, 9,
-	[maxCodeLen + 1]int{7: 23, 199, 511},
-	[maxCodeLen + 1]int{7: 0, 24, 224},
-	[]int{
-		// length 7: 256-279
-		256, 257, 258, 259, 260, 261, 262,
-		263, 264, 265, 266, 267, 268, 269,
-		270, 271, 272, 273, 274, 275, 276,
-		277, 278, 279,
-
-		// length 8: 0-143
-		0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
-		12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
-		22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
-		32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
-		42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
-		52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
-		62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
-		72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
-		82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
-		92, 93, 94, 95, 96, 97, 98, 99, 100,
-		101, 102, 103, 104, 105, 106, 107, 108,
-		109, 110, 111, 112, 113, 114, 115, 116,
-		117, 118, 119, 120, 121, 122, 123, 124,
-		125, 126, 127, 128, 129, 130, 131, 132,
-		133, 134, 135, 136, 137, 138, 139, 140,
-		141, 142, 143,
-
-		// length 8: 280-287
-		280, 281, 282, 283, 284, 285, 286, 287,
-
-		// length 9: 144-255
-		144, 145, 146, 147, 148, 149, 150, 151,
-		152, 153, 154, 155, 156, 157, 158, 159,
-		160, 161, 162, 163, 164, 165, 166, 167,
-		168, 169, 170, 171, 172, 173, 174, 175,
-		176, 177, 178, 179, 180, 181, 182, 183,
-		184, 185, 186, 187, 188, 189, 190, 191,
-		192, 193, 194, 195, 196, 197, 198, 199,
-		200, 201, 202, 203, 204, 205, 206, 207,
-		208, 209, 210, 211, 212, 213, 214, 215,
-		216, 217, 218, 219, 220, 221, 222, 223,
-		224, 225, 226, 227, 228, 229, 230, 231,
-		232, 233, 234, 235, 236, 237, 238, 239,
-		240, 241, 242, 243, 244, 245, 246, 247,
-		248, 249, 250, 251, 252, 253, 254, 255,
-	},
-}
-
-// Huffman decoder is based on
-// J. Brian Connell, ``A Huffman-Shannon-Fano Code,''
-// Proceedings of the IEEE, 61(7) (July 1973), pp 1046-1047.
-type huffmanDecoder struct {
-	// min, max code length
-	min, max int
-
-	// limit[i] = largest code word of length i
-	// Given code v of length n,
-	// need more bits if v > limit[n].
-	limit [maxCodeLen + 1]int
-
-	// base[i] = smallest code word of length i - seq number
-	base [maxCodeLen + 1]int
-
-	// codes[seq number] = output code.
-	// Given code v of length n, value is
-	// codes[v - base[n]].
-	codes []int
-}
-
-// Initialize Huffman decoding tables from array of code lengths.
-func (h *huffmanDecoder) init(bits []int) bool {
-	// Count number of codes of each length,
-	// compute min and max length.
-	var count [maxCodeLen + 1]int
-	var min, max int
-	for _, n := range bits {
-		if n == 0 {
-			continue
-		}
-		if min == 0 || n < min {
-			min = n
-		}
-		if n > max {
-			max = n
-		}
-		count[n]++
-	}
-	if max == 0 {
-		return false
-	}
-
-	h.min = min
-	h.max = max
-
-	// For each code range, compute
-	// nextcode (first code of that length),
-	// limit (last code of that length), and
-	// base (offset from first code to sequence number).
-	code := 0
-	seq := 0
-	var nextcode [maxCodeLen]int
-	for i := min; i <= max; i++ {
-		n := count[i]
-		nextcode[i] = code
-		h.base[i] = code - seq
-		code += n
-		seq += n
-		h.limit[i] = code - 1
-		code <<= 1
-	}
-
-	// Make array mapping sequence numbers to codes.
-	if len(h.codes) < len(bits) {
-		h.codes = make([]int, len(bits))
-	}
-	for i, n := range bits {
-		if n == 0 {
-			continue
-		}
-		code := nextcode[n]
-		nextcode[n]++
-		seq := code - h.base[n]
-		h.codes[seq] = i
-	}
-	return true
-}
-
-func inflate(in string) (out []byte) {
-	var d decompressor
-	d.in = in
-	for !d.err && !d.eof {
-		d.nextBlock()
-	}
-	if len(d.in) != 0 {
-		println("fs unzip: junk at end of compressed data")
-		return nil
-	}
-	return d.out
-}
-
-// get4 returns the little-endian 32-bit value in b.
-func zget4(b string) int {
-	if len(b) < 4 {
-		return 0
-	}
-	return int(b[0]) | int(b[1])<<8 | int(b[2])<<16 | int(b[3])<<24
-}
-
-// get2 returns the little-endian 16-bit value in b.
-func zget2(b string) int {
-	if len(b) < 2 {
-		return 0
-	}
-	return int(b[0]) | int(b[1])<<8
-}
-
-func unzip(data string) {
-	const (
-		zecheader   = 0x06054b50
-		zcheader    = 0x02014b50
-		ztailsize   = 22
-		zheadersize = 30
-		zheader     = 0x04034b50
-	)
-
-	buf := data[len(data)-ztailsize:]
-	n := zget2(buf[10:])
-	size := zget4(buf[12:])
-	off := zget4(buf[16:])
-
-	hdr := data[off : off+size]
-	for i := 0; i < n; i++ {
-		// zip entry layout:
-		//	0	magic[4]
-		//	4	madevers[1]
-		//	5	madeos[1]
-		//	6	extvers[1]
-		//	7	extos[1]
-		//	8	flags[2]
-		//	10	meth[2]
-		//	12	modtime[2]
-		//	14	moddate[2]
-		//	16	crc[4]
-		//	20	csize[4]
-		//	24	uncsize[4]
-		//	28	namelen[2]
-		//	30	xlen[2]
-		//	32	fclen[2]
-		//	34	disknum[2]
-		//	36	iattr[2]
-		//	38	eattr[4]
-		//	42	off[4]
-		//	46	name[namelen]
-		//	46+namelen+xlen+fclen - next header
-		//
-		if zget4(hdr) != zcheader {
-			println("fs unzip: bad magic")
-			break
-		}
-		meth := zget2(hdr[10:])
-		mtime := zget2(hdr[12:])
-		mdate := zget2(hdr[14:])
-		csize := zget4(hdr[20:])
-		size := zget4(hdr[24:])
-		namelen := zget2(hdr[28:])
-		xlen := zget2(hdr[30:])
-		fclen := zget2(hdr[32:])
-		xattr := uint32(zget4(hdr[38:])) >> 16
-		off := zget4(hdr[42:])
-		name := hdr[46 : 46+namelen]
-		hdr = hdr[46+namelen+xlen+fclen:]
-
-		// zip per-file header layout:
-		//	0	magic[4]
-		//	4	extvers[1]
-		//	5	extos[1]
-		//	6	flags[2]
-		//	8	meth[2]
-		//	10	modtime[2]
-		//	12	moddate[2]
-		//	14	crc[4]
-		//	18	csize[4]
-		//	22	uncsize[4]
-		//	26	namelen[2]
-		//	28	xlen[2]
-		//	30	name[namelen]
-		//	30+namelen+xlen - file data
-		//
-		buf := data[off : off+zheadersize+namelen]
-		if zget4(buf) != zheader ||
-			zget2(buf[8:]) != meth ||
-			zget2(buf[26:]) != namelen ||
-			buf[30:30+namelen] != name {
-			println("fs unzip: inconsistent zip file")
-			return
-		}
-		xlen = zget2(buf[28:])
-
-		off += zheadersize + namelen + xlen
-
-		var fdata []byte
-		switch meth {
-		case 0:
-			// buf is uncompressed
-			buf = data[off : off+size]
-			fdata = []byte(buf)
-		case 8:
-			// buf is deflate-compressed
-			buf = data[off : off+csize]
-			fdata = inflate(buf)
-			if len(fdata) != size {
-				println("fs unzip: inconsistent size in zip file")
-				return
-			}
-		}
-
-		if xattr&S_IFMT == 0 {
-			if xattr&0777 == 0 {
-				xattr |= 0666
-			}
-			if len(name) > 0 && name[len(name)-1] == '/' {
-				xattr |= S_IFDIR
-				xattr |= 0111
-			} else {
-				xattr |= S_IFREG
-			}
-		}
-
-		if err := create(name, xattr, zipToTime(mdate, mtime), fdata); err != nil {
-			print("fs unzip: create ", name, ": ", err.Error(), "\n")
-		}
-	}
-
-	chdirEnv()
-}
-
-func zipToTime(date, time int) int64 {
-	dd := date & 0x1f
-	mm := date >> 5 & 0xf
-	yy := date >> 9 // since 1980
-
-	sec := int64(315532800) // jan 1 1980
-	sec += int64(yy) * 365 * 86400
-	sec += int64(yy) / 4 * 86400
-	if yy%4 > 0 || mm >= 3 {
-		sec += 86400
-	}
-	sec += int64(daysBeforeMonth[mm]) * 86400
-	sec += int64(dd-1) * 86400
-
-	h := time >> 11
-	m := time >> 5 & 0x3F
-	s := time & 0x1f * 2
-	sec += int64(h*3600 + m*60 + s)
-
-	return sec
-}
-
-var daysBeforeMonth = [...]int32{
-	0,
-	0,
-	31,
-	31 + 28,
-	31 + 28 + 31,
-	31 + 28 + 31 + 30,
-	31 + 28 + 31 + 30 + 31,
-	31 + 28 + 31 + 30 + 31 + 30,
-	31 + 28 + 31 + 30 + 31 + 30 + 31,
-	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31,
-	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
-	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
-	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30,
-	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31,
-}

unix/zsyscall_nacl_386.go

@@ -1,63 +0,0 @@
-// mkunix.pl -l32 -nacl syscall_nacl.go syscall_nacl_386.go
-// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
-
-package unix
-
-import "unsafe"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func naclClose(fd int) (err error) {
-	_, _, e1 := Syscall(sys_close, uintptr(fd), 0, 0)
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Exit(code int) (err error) {
-	_, _, e1 := Syscall(sys_exit, uintptr(code), 0, 0)
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func naclFstat(fd int, stat *Stat_t) (err error) {
-	_, _, e1 := Syscall(sys_fstat, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func naclRead(fd int, b []byte) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(b) > 0 {
-		_p0 = unsafe.Pointer(&b[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(sys_read, uintptr(fd), uintptr(_p0), uintptr(len(b)))
-	n = int(r0)
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func naclSeek(fd int, off *int64, whence int) (err error) {
-	_, _, e1 := Syscall(sys_lseek, uintptr(fd), uintptr(unsafe.Pointer(off)), uintptr(whence))
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}

unix/zsyscall_nacl_amd64p32.go

@@ -1,63 +0,0 @@
-// mkunix.pl -nacl syscall_nacl.go syscall_nacl_amd64p32.go
-// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
-
-package unix
-
-import "unsafe"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func naclClose(fd int) (err error) {
-	_, _, e1 := Syscall(sys_close, uintptr(fd), 0, 0)
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Exit(code int) (err error) {
-	_, _, e1 := Syscall(sys_exit, uintptr(code), 0, 0)
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func naclFstat(fd int, stat *Stat_t) (err error) {
-	_, _, e1 := Syscall(sys_fstat, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func naclRead(fd int, b []byte) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(b) > 0 {
-		_p0 = unsafe.Pointer(&b[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(sys_read, uintptr(fd), uintptr(_p0), uintptr(len(b)))
-	n = int(r0)
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func naclSeek(fd int, off *int64, whence int) (err error) {
-	_, _, e1 := Syscall(sys_lseek, uintptr(fd), uintptr(unsafe.Pointer(off)), uintptr(whence))
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}

unix/zsyscall_nacl_arm.go

@@ -1,63 +0,0 @@
-// mkunix.pl -l32 -nacl -arm syscall_nacl.go syscall_nacl_arm.go
-// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
-
-package unix
-
-import "unsafe"
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func naclClose(fd int) (err error) {
-	_, _, e1 := Syscall(sys_close, uintptr(fd), 0, 0)
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Exit(code int) (err error) {
-	_, _, e1 := Syscall(sys_exit, uintptr(code), 0, 0)
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func naclFstat(fd int, stat *Stat_t) (err error) {
-	_, _, e1 := Syscall(sys_fstat, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func naclRead(fd int, b []byte) (n int, err error) {
-	var _p0 unsafe.Pointer
-	if len(b) > 0 {
-		_p0 = unsafe.Pointer(&b[0])
-	} else {
-		_p0 = unsafe.Pointer(&_zero)
-	}
-	r0, _, e1 := Syscall(sys_read, uintptr(fd), uintptr(_p0), uintptr(len(b)))
-	n = int(r0)
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func naclSeek(fd int, off *int64, whence int) (err error) {
-	_, _, e1 := Syscall(sys_lseek, uintptr(fd), uintptr(unsafe.Pointer(off)), uintptr(whence))
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}