mirror of
https://github.com/rwinkhart/sys.git
synced 2026-08-27 20:36:31 -04:00
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
This commit is contained in:
Rob Pike
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
+1
-1
@@ -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.
|
||||
|
||||
|
||||
-326
@@ -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
|
||||
}
|
||||
-832
@@ -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
|
||||
}
|
||||
@@ -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"
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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 }
|
||||
@@ -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
|
||||
}
|
||||
@@ -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 }
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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",
|
||||
}
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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,
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
Reference in New Issue
Block a user