// license that can be found in the LICENSE file.

// This code was translated into a form compatible with 6a from the public

#define REDMASK51 0x0007FFFFFFFFFFFF

// license that can be found in the LICENSE file.

// This code was translated into a form compatible with 6a from the public

// +build amd64,!gccgo,!appengine

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// non-amd64 platforms. The amd64 assembly does not support gccgo.

// +build !amd64 gccgo appengine

// license that can be found in the LICENSE file.

// Package curve25519 provides an implementation of scalar multiplication on

package curve25519 // import "golang.org/x/crypto/curve25519"

// basePoint is the x coordinate of the generator of the curve.

// license that can be found in the LICENSE file.

// This code was translated into a form compatible with 6a from the public

// +build amd64,!gccgo,!appengine

// license that can be found in the LICENSE file.

// This code was translated into a form compatible with 6a from the public

// +build amd64,!gccgo,!appengine

// license that can be found in the LICENSE file.

// This code was translated into a form compatible with 6a from the public

// +build amd64,!gccgo,!appengine

// license that can be found in the LICENSE file.

// This code was translated into a form compatible with 6a from the public

// +build amd64,!gccgo,!appengine

// license that can be found in the LICENSE file.

// Package ed25519 implements the Ed25519 signature algorithm. See

//

// These functions are also compatible with the “Ed25519” function defined in

package ed25519

// This code is a port of the public domain, “ref10” implementation of ed25519

// from SUPERCOP.

import (

"crypto"

cryptorand "crypto/rand"

"crypto/sha512"

"errors"

"io"

"strconv"

var checkR [32]byte

R.ToBytes(&checkR)

}

return nil, ske.CipherFunc, errors.UnsupportedError("unknown cipher: " + strconv.Itoa(int(cipherFunc)))

}

plaintextKey = plaintextKey[1:]

}

return plaintextKey, cipherFunc, nil

}

// Package scrypt implements the scrypt key derivation function as defined in

// Colin Percival's paper "Stronger Key Derivation via Sequential Memory-Hard

package scrypt // import "golang.org/x/crypto/scrypt"

import (

//

// dk, err := scrypt.Key([]byte("some password"), salt, 16384, 8, 1, 32)

//

func Key(password, salt []byte, N, r, p, keyLen int) ([]byte, error) {

if N <= 1 || N&(N-1) != 0 {

return nil, errors.New("scrypt: N must be > 1 and a power of 2")

}

// eof closes the buffer. Reads from the buffer once all

b.Cond.L.Lock()

b.closed = true

b.Cond.Signal()

b.Cond.L.Unlock()

}

// Read reads data from the internal buffer in buf. Reads will block

// for user certificates.

SupportedCriticalOptions []string

// Clock is used for verifying time stamps. If nil, time.Now

// is used.

if cert.CertType != HostCert {

return fmt.Errorf("ssh: certificate presented as a host key has type %d", cert.CertType)

}

}

// Authenticate checks a user certificate. Authenticate can be used as

if cert.CertType != UserCert {

return nil, fmt.Errorf("ssh: cert has type %d", cert.CertType)

}

if err := c.CheckCert(conn.User(), cert); err != nil {

return nil, err

}

}

clock := c.Clock

if clock == nil {

clock = time.Now

buf []byte

}

c, err := aes.NewCipher(key)

if err != nil {

return nil, err

c.incIV()

padding := plain[0]

return nil, fmt.Errorf("ssh: illegal padding %d", padding)

}

// both CLI and GUI environments.

type KeyboardInteractiveChallenge func(user, instruction string, questions []string, echos []bool) (answers []string, err error)

// sequence controlled by the server.

func KeyboardInteractive(challenge KeyboardInteractiveChallenge) AuthMethod {

return challenge

// User returns the user ID for this connection.

User() string

SessionID() []byte

// ClientVersion returns the client's version string as hashed

// 4253 and Oakley Group 2 in RFC 2409.

p, _ := new(big.Int).SetString("FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381FFFFFFFFFFFFFFFF", 16)

kexAlgoMap[kexAlgoDH1SHA1] = &dhGroup{

pMinus1: new(big.Int).Sub(p, bigOne),

}

p, _ = new(big.Int).SetString("FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AACAA68FFFFFFFFFFFFFFFF", 16)

kexAlgoMap[kexAlgoDH14SHA1] = &dhGroup{

pMinus1: new(big.Int).Sub(p, bigOne),

}

return "ssh-dss"

}

// parseDSA parses an DSA key according to RFC 4253, section 6.6.

func parseDSA(in []byte) (out PublicKey, rest []byte, err error) {

var w struct {

return nil, nil, err

}

key := &dsaPublicKey{

}

return key, w.Rest, nil

}

}

// NewSignerFromKey takes an *rsa.PrivateKey, *dsa.PrivateKey,

func NewSignerFromKey(key interface{}) (Signer, error) {

switch key := key.(type) {

case crypto.Signer:

return NewSignerFromSigner(key)

case *dsa.PrivateKey:

default:

return nil, fmt.Errorf("ssh: unsupported key type %T", key)

}

}

type wrappedSigner struct {

signer crypto.Signer

pubKey PublicKey

return NewSignerFromKey(key)

}

// encryptedBlock tells whether a private key is

// encrypted by examining its Proc-Type header

// for a mention of ENCRYPTED

}

}

// ParseDSAPrivateKey returns a DSA private key from its ASN.1 DER encoding, as

// specified by the OpenSSL DSA man page.

func ParseDSAPrivateKey(der []byte) (*dsa.PrivateKey, error) {

)

// The Permissions type holds fine-grained permissions that are

type Permissions struct {

CriticalOptions map[string]string

// Extensions are extra functionality that the server may

Extensions map[string]string

}

// attempts to authenticate using a password.

PasswordCallback func(conn ConnMetadata, password []byte) (*Permissions, error)

PublicKeyCallback func(conn ConnMetadata, key PublicKey) (*Permissions, error)

// KeyboardInteractiveCallback, if non-nil, is called when

// Request and NewChannel channels must be serviced, or the connection

// will hang.

func NewServerConn(c net.Conn, config *ServerConfig) (*ServerConn, <-chan NewChannel, <-chan *Request, error) {

fullConf := *config

fullConf.SetDefaults()

s := &connection{

sshConn: sshConn{conn: c},

}

return fmt.Errorf("ssh: remote address %v is not allowed because of source-address restriction", addr)

}

func (s *connection) serverAuthenticate(config *ServerConfig) (*Permissions, error) {

sessionID := s.transport.getSessionID()

var cache pubKeyCache

var perms *Permissions

authFailures := 0

userAuthLoop:

for {

var userAuthReq userAuthRequestMsg

if packet, err := s.transport.readPacket(); err != nil {

return nil, err

} else if err = Unmarshal(packet, &userAuthReq); err != nil {

return nil, err

authErr = fmt.Errorf("ssh: unknown method %q", userAuthReq.Method)

}

if config.AuthLogCallback != nil {

config.AuthLogCallback(s, userAuthReq.Method, authErr)

}

return err

}

// RFC 4254 Section 6.9.

type signalMsg struct {

Signal string

package terminal // import "golang.org/x/crypto/ssh/terminal"

import (

)

// State contains the state of a terminal.

type State struct {

}

// IsTerminal returns true if the given file descriptor is a terminal.

func IsTerminal(fd int) bool {

}

// MakeRaw put the terminal connected to the given file descriptor into raw

// mode and returns the previous state of the terminal so that it can be

// restored.

func MakeRaw(fd int) (*State, error) {

return nil, err

}

// This attempts to replicate the behaviour documented for cfmakeraw in

// the termios(3) manpage.

return nil, err

}

// GetState returns the current state of a terminal which may be useful to

// restore the terminal after a signal.

func GetState(fd int) (*State, error) {

return nil, err

}

}

// Restore restores the terminal connected to the given file descriptor to a

// previous state.

func Restore(fd int, state *State) error {

}

// GetSize returns the dimensions of the given terminal.

func GetSize(fd int) (width, height int, err error) {

return -1, -1, err

}

}

// passwordReader is an io.Reader that reads from a specific file descriptor.

type passwordReader int

func (r passwordReader) Read(buf []byte) (int, error) {

}

// ReadPassword reads a line of input from a terminal without local echo. This

// is commonly used for inputting passwords and other sensitive data. The slice

// returned does not include the \n.

func ReadPassword(fd int) ([]byte, error) {

return nil, err

}

return nil, err

}

defer func() {

}()

return readPasswordLine(passwordReader(fd))

package terminal

package terminal

package terminal

import (

)

type State struct {

// IsTerminal returns true if the given file descriptor is a terminal.

func IsTerminal(fd int) bool {

var st uint32

}

// MakeRaw put the terminal connected to the given file descriptor into raw

// restored.

func MakeRaw(fd int) (*State, error) {

var st uint32

}

}

return &State{st}, nil

}

// restore the terminal after a signal.

func GetState(fd int) (*State, error) {

var st uint32

}

return &State{st}, nil

}

// Restore restores the terminal connected to the given file descriptor to a

// previous state.

func Restore(fd int, state *State) error {

}

// GetSize returns the dimensions of the given terminal.

func GetSize(fd int) (width, height int, err error) {

}

}

// passwordReader is an io.Reader that reads from a specific Windows HANDLE.

type passwordReader int

func (r passwordReader) Read(buf []byte) (int, error) {

}

// ReadPassword reads a line of input from a terminal without local echo. This

// returned does not include the \n.

func ReadPassword(fd int) ([]byte, error) {

var st uint32

}

old := st

}

defer func() {

}()

return readPasswordLine(passwordReader(fd))

iv, key, macKey := generateKeys(d, algs, kex)

if algs.Cipher == gcmCipherID {

}

if algs.Cipher == aes128cbcID {

// System calls for amd64, Solaris are implemented in runtime/syscall_solaris.go

//

JMP syscall·sysvicall6(SB)

JMP syscall·rawSysvicall6(SB)

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

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

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

import "syscall"

// much of the functionality can be written directly in Go.

//extern gccgoRealSyscall

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

# Use of this source code is governed by a BSD-style

# license that can be found in the LICENSE file.

GOOSARCH="${GOOS}_${GOARCH}"

mksysnum=

mktypes=

run="sh"

case "$1" in

-syscalls)

;;

-n)

run="cat"

shift

esac

exit 2

esac

GOOSARCH_in=syscall_$GOOSARCH.go

case "$GOOSARCH" in

_* | *_ | _)

;;

darwin_arm)

mkerrors="$mkerrors"

mktypes="GOARCH=$GOARCH go tool cgo -godefs"

;;

darwin_arm64)

mksyscall="./mksyscall.pl -l32 -arm"

mksysnum="curl -s 'http://svn.freebsd.org/base/stable/10/sys/kern/syscalls.master' | ./mksysnum_freebsd.pl"

# Let the type of C char be signed for making the bare syscall

mktypes="GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char"

;;

linux_sparc64)

mksysnum="curl -s 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master' | ./mksysnum_netbsd.pl"

mktypes="GOARCH=$GOARCH go tool cgo -godefs"

;;

openbsd_386)

mkerrors="$mkerrors -m32"

mksyscall="./mksyscall.pl -l32 -openbsd"

mksysctl="./mksysctl_openbsd.pl"

mksysnum="curl -s 'http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master' | ./mksysnum_openbsd.pl"

mktypes="GOARCH=$GOARCH go tool cgo -godefs"

;;

mkerrors="$mkerrors -m64"

mksyscall="./mksyscall.pl -openbsd"

mksysctl="./mksysctl_openbsd.pl"

mksysnum="curl -s 'http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master' | ./mksysnum_openbsd.pl"

mktypes="GOARCH=$GOARCH go tool cgo -godefs"

;;

solaris_amd64)

mksyscall="./mksyscall_solaris.pl"

mkerrors="$mkerrors -m64"

if [ -n "$mksysctl" ]; then echo "$mksysctl |gofmt >$zsysctl"; fi

if [ -n "$mksysnum" ]; then echo "$mksysnum |gofmt >zsysnum_$GOOSARCH.go"; fi

if [ -n "$mktypes" ]; then

fi

) | $run

exit 1

fi

CC=${CC:-cc}

# Assumes GNU versions of utilities in PATH.

export PATH=/usr/gnu/bin:$PATH

fi

#define _DARWIN_C_SOURCE

#define KERNEL

#define _DARWIN_USE_64_BIT_INODE

#include <sys/types.h>

#include <sys/event.h>

#include <sys/ptrace.h>

#include <sys/sockio.h>

#include <sys/sysctl.h>

#include <sys/mman.h>

#include <sys/wait.h>

#include <net/bpf.h>

#include <net/if.h>

'

includes_FreeBSD='

#include <sys/param.h>

#include <sys/types.h>

#include <sys/event.h>

#include <sys/sockio.h>

#include <sys/sysctl.h>

#include <sys/mman.h>

#include <sys/wait.h>

#include <sys/ioctl.h>

#include <net/bpf.h>

#endif

#define _GNU_SOURCE

#include <bits/sockaddr.h>

#include <sys/epoll.h>

#include <sys/inotify.h>

#include <sys/ioctl.h>

#include <sys/mman.h>

#include <sys/types.h>

#include <sys/time.h>

#include <sys/socket.h>

#include <linux/if.h>

#include <linux/if_alg.h>

#include <linux/if_arp.h>

#include <linux/if_addr.h>

#include <linux/falloc.h>

#include <linux/filter.h>

#include <linux/netlink.h>

#include <linux/reboot.h>

#include <linux/rtnetlink.h>

#include <linux/ptrace.h>

#include <linux/sched.h>

#include <linux/wait.h>

#include <linux/icmpv6.h>

#include <linux/serial.h>

#include <linux/can.h>

#include <net/route.h>

#include <asm/termbits.h>

#define PTRACE_SETREGS 0xd

#endif

#ifdef SOL_BLUETOOTH

// SPARC includes this in /usr/include/sparc64-linux-gnu/bits/socket.h

// but it is already in bluetooth_linux.go

#undef SOL_BLUETOOTH

#endif

'

includes_NetBSD='

#include <sys/mman.h>

#include <sys/wait.h>

#include <sys/ioctl.h>

#include <net/bpf.h>

#include <net/if.h>

#include <net/if_arp.h>

$2 !~ /^EXPR_/ &&

$2 ~ /^E[A-Z0-9_]+$/ ||

$2 ~ /^B[0-9_]+$/ ||

$2 == "BOTHER" ||

$2 ~ /^CI?BAUD(EX)?$/ ||

$2 == "IBSHIFT" ||

$2 == "IFNAMSIZ" ||

$2 ~ /^CTL_(MAXNAME|NET|QUERY)$/ ||

$2 ~ /^SYSCTL_VERS/ ||

$2 ~ /^TUN(SET|GET|ATTACH|DETACH)/ ||

$2 ~ /^LINUX_REBOOT_CMD_/ ||

$2 ~ /^LINUX_REBOOT_MAGIC[12]$/ ||

$2 !~ "NLA_TYPE_MASK" &&

$2 ~ /^(IFF|IFT|NET_RT|RTM|RTF|RTV|RTA|RTAX)_/ ||

$2 ~ /^BIOC/ ||

$2 ~ /^RUSAGE_(SELF|CHILDREN|THREAD)/ ||

$2 ~ /^PRIO_(PROCESS|PGRP|USER)/ ||

$2 ~ /^CLONE_[A-Z_]+/ ||

$2 !~ /^(BPF_TIMEVAL)$/ &&

$2 ~ /^(BPF|DLT)_/ ||

$2 ~ /^CLOCK_/ ||

$2 ~ /^CAN_/ ||

$2 ~ /^ALG_/ ||

$2 !~ "WMESGLEN" &&

$2 ~ /^__WCOREFLAG$/ {next}

$2 ~ /^__W[A-Z0-9]+$/ {printf("\t%s = C.%s\n", substr($2,3), $2)}

sort >_signal.grep

echo '// mkerrors.sh' "$@"

echo

echo "// +build ${GOARCH},${GOOS}"

echo

int

main(void)

{

char buf[1024], *p;

printf("\n\n// Error table\n");

printf("\t%d: \"%s\",\n", e, buf);

}

printf("}\n\n");

printf("\n\n// Signal table\n");

printf("var signals = [...]string {\n");

qsort(signals, nelem(signals), sizeof signals[0], intcmp);

exit 1;

}

sub parseparamlist($) {

my ($list) = @_;

$list =~ s/^\s*//;

print <<EOF;

// $cmdline

// +build $tags

print <<EOF;

// $cmdline

// +build $tags

print <<EOF;

// $command

// +build $ENV{'GOARCH'},$ENV{'GOOS'}

print <<EOF;

// $command

// +build $ENV{'GOARCH'},$ENV{'GOOS'}

print <<EOF;

// $command

// +build $ENV{'GOARCH'},$ENV{'GOOS'}

if($name eq 'SYS_SYS_EXIT'){

$name = 'SYS_EXIT';

}

print " $name = $num; // $proto\n";

}

}

print <<EOF;

// $command

// +build $ENV{'GOARCH'},$ENV{'GOOS'}

$name = "$7_$11" if $11 ne '';

$name =~ y/a-z/A-Z/;

print " $name = $num; // $proto\n";

}

}

print <<EOF;

// $command

// +build $ENV{'GOARCH'},$ENV{'GOOS'}

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// Round the length of a raw sockaddr up to align it properly.

func cmsgAlignOf(salen int) int {

salign := sizeofPtr

salign = 4

}

return (salen + salign - 1) & ^(salign - 1)

// +build darwin dragonfly freebsd linux netbsd openbsd solaris

// Package unix contains an interface to the low-level operating system

// by default, godoc will display OS-specific documentation for the current

// you want to view documentation for freebsd/arm on linux/amd64, set $GOOS

// to freebsd and $GOARCH to arm.

// The primary use of this package is inside other packages that provide a more

// Single-word zero for use when we need a valid pointer to 0 bytes.

// See mkunix.pl.

var _zero uintptr

return nil, nil

}

if n < 0 || n > 1000 {

return nil, EINVAL

}

func UtimesNano(path string, ts []Timespec) error {

if ts == nil {

return utimes(path, nil)

}

if len(ts) != 2 {

return EINVAL

}

// Not as efficient as it could be because Timespec and

// Timeval have different types in the different OSes

tv := [2]Timeval{

return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))

}

//sys futimes(fd int, timeval *[2]Timeval) (err error)

func Futimes(fd int, tv []Timeval) error {

//sys fcntl(fd int, cmd int, arg int) (val int, err error)

// TODO: wrap

// Acct(name nil-string) (err error)

// Gethostuuid(uuid *byte, timeout *Timespec) (err error)

// Ptrace(req int, pid int, addr uintptr, data int) (ret uintptr, err error)

var mapper = &mmapper{

func Munmap(b []byte) (err error) {

return mapper.Munmap(b)

}

// NOTE(rsc): It seems strange to set the buffer to have

// size CTL_MAXNAME+2 but use only CTL_MAXNAME

// kernel uses +2 for its own implementation of this function.

// I am scared that if we don't include the +2 here, the kernel

// will silently write 2 words farther than we specify

return buf[0 : n/siz], nil

}

}

//sys ptrace(request int, pid int, addr uintptr, data uintptr) (err error)

return

}

/*

* Wrapped

*/

func Kill(pid int, signum syscall.Signal) (err error) { return kill(pid, int(signum), 1) }

/*

* Exposed directly

*/

//sys Dup2(from int, to int) (err error)

//sys Exchangedata(path1 string, path2 string, options int) (err error)

//sys Exit(code int)

//sys Fchdir(fd int) (err error)

//sys Fchflags(fd int, flags int) (err error)

//sys Fchmod(fd int, mode uint32) (err error)

//sys Fchown(fd int, uid int, gid int) (err error)

//sys Flock(fd int, how int) (err error)

//sys Fpathconf(fd int, name int) (val int, err error)

//sys Fstat(fd int, stat *Stat_t) (err error) = SYS_FSTAT64

//sys Kqueue() (fd int, err error)

//sys Lchown(path string, uid int, gid int) (err error)

//sys Link(path string, link string) (err error)

//sys Listen(s int, backlog int) (err error)

//sys Lstat(path string, stat *Stat_t) (err error) = SYS_LSTAT64

//sys Mkdir(path string, mode uint32) (err error)

//sys Mkfifo(path string, mode uint32) (err error)

//sys Mknod(path string, mode uint32, dev int) (err error)

//sys Open(path string, mode int, perm uint32) (fd int, err error)

//sys Pathconf(path string, name int) (val int, err error)

//sys Pread(fd int, p []byte, offset int64) (n int, err error)

//sys Pwrite(fd int, p []byte, offset int64) (n int, err error)

//sys read(fd int, p []byte) (n int, err error)

//sys Readlink(path string, buf []byte) (n int, err error)

//sys Rename(from string, to string) (err error)

//sys Revoke(path string) (err error)

//sys Rmdir(path string) (err error)

//sys Seek(fd int, offset int64, whence int) (newoffset int64, err error) = SYS_LSEEK

//sys Stat(path string, stat *Stat_t) (err error) = SYS_STAT64

//sys Statfs(path string, stat *Statfs_t) (err error) = SYS_STATFS64

//sys Symlink(path string, link string) (err error)

//sys Sync() (err error)

//sys Truncate(path string, length int64) (err error)

//sys Umask(newmask int) (oldmask int)

//sys Undelete(path string) (err error)

//sys Unlink(path string) (err error)

//sys Unmount(path string, flags int) (err error)

//sys write(fd int, p []byte) (n int, err error)

//sys mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)

// Add_profil

// Kdebug_trace

// Sigreturn

// Atsocket

// Kqueue_from_portset_np

// Kqueue_portset

// Searchfs

// Delete

// Copyfile

// Watchevent

// Waitevent

// Modwatch

// Lio_listio

// __pthread_cond_wait

// Iopolicysys

// __pthread_kill

// __pthread_sigmask

// __sigwait

// Sendmsg_nocancel

// Recvfrom_nocancel

// Accept_nocancel

// Fcntl_nocancel

// Select_nocancel

// Fsync_nocancel

"unsafe"

)

}

}

//sysnb gettimeofday(tp *Timeval) (sec int32, usec int32, err error)

func Gettimeofday(tv *Timeval) (err error) {

// The tv passed to gettimeofday must be non-nil

// in the two registers.

sec, usec, err := gettimeofday(tv)

tv.Sec = int32(sec)

"unsafe"

)

}

}

//sysnb gettimeofday(tp *Timeval) (sec int64, usec int32, err error)

func Gettimeofday(tv *Timeval) (err error) {

// The tv passed to gettimeofday must be non-nil

// in the two registers.

sec, usec, err := gettimeofday(tv)

tv.Sec = sec

"unsafe"

)

}

}

//sysnb gettimeofday(tp *Timeval) (sec int32, usec int32, err error)

func Gettimeofday(tv *Timeval) (err error) {

// The tv passed to gettimeofday must be non-nil

// in the two registers.

sec, usec, err := gettimeofday(tv)

tv.Sec = int32(sec)

"unsafe"

)

}

}

//sysnb gettimeofday(tp *Timeval) (sec int64, usec int32, err error)

func Gettimeofday(tv *Timeval) (err error) {

// The tv passed to gettimeofday must be non-nil

// in the two registers.

sec, usec, err := gettimeofday(tv)

tv.Sec = sec

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// This file is compiled as ordinary Go code,

// but it is also input to mksyscall,

// which parses the //sys lines and generates system call stubs.

// NOTE(rsc): It seems strange to set the buffer to have

// size CTL_MAXNAME+2 but use only CTL_MAXNAME

// kernel uses +2 for its own implementation of this function.

// I am scared that if we don't include the +2 here, the kernel

// will silently write 2 words farther than we specify

return buf[0 : n/siz], nil

}

}

}

//sysnb pipe() (r int, w int, err error)

return extpwrite(fd, p, 0, offset)

}

func Getfsstat(buf []Statfs_t, flags int) (n int, err error) {

var _p0 unsafe.Pointer

var bufsize uintptr

return

}

/*

* Exposed directly

*/

//sys Mkdir(path string, mode uint32) (err error)

//sys Mkfifo(path string, mode uint32) (err error)

//sys Mknod(path string, mode uint32, dev int) (err error)

//sys Nanosleep(time *Timespec, leftover *Timespec) (err error)

//sys Open(path string, mode int, perm uint32) (fd int, err error)

//sys Pathconf(path string, name int) (val int, err error)

//sys munmap(addr uintptr, length uintptr) (err error)

//sys readlen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_READ

//sys writelen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_WRITE

/*

* Unimplemented

// Getlogin

// Sigpending

// Sigaltstack

// Reboot

// Execve

// Vfork

// Add_profil

// Kdebug_trace

// Sigreturn

// Atsocket

// Kqueue_from_portset_np

// Kqueue_portset

// Searchfs

// Delete

// Copyfile

// Watchevent

// Waitevent

// Modwatch

// Sendmsg_nocancel

// Recvfrom_nocancel

// Accept_nocancel

// Fcntl_nocancel

// Select_nocancel

// Fsync_nocancel

// Pread_nocancel

// Pwrite_nocancel

// Waitid_nocancel

// Msgsnd_nocancel

// Msgrcv_nocancel

// Sem_wait_nocancel

"unsafe"

)

}

}

func SetKevent(k *Kevent_t, fd, mode, flags int) {

// NOTE(rsc): It seems strange to set the buffer to have

// size CTL_MAXNAME+2 but use only CTL_MAXNAME

// kernel uses +2 for its own implementation of this function.

// I am scared that if we don't include the +2 here, the kernel

// will silently write 2 words farther than we specify

return buf[0 : n/siz], nil

}

}

//sysnb pipe() (r int, w int, err error)

return

}

// Derive extattr namespace and attribute name

func xattrnamespace(fullattr string) (ns int, attr string, err error) {

return s, e

}

/*

* Exposed directly

*/

//sys Access(path string, mode uint32) (err error)

//sys Adjtime(delta *Timeval, olddelta *Timeval) (err error)

//sys Chdir(path string) (err error)

//sys Chflags(path string, flags int) (err error)

//sys Chmod(path string, mode uint32) (err error)

//sys ExtattrDeleteLink(link string, attrnamespace int, attrname string) (err error)

//sys ExtattrListLink(link string, attrnamespace int, data uintptr, nbytes int) (ret int, err error)

//sys Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_POSIX_FADVISE

//sys Fchdir(fd int) (err error)

//sys Fchflags(fd int, flags int) (err error)

//sys Fchmod(fd int, mode uint32) (err error)

//sys Fchown(fd int, uid int, gid int) (err error)

//sys Flock(fd int, how int) (err error)

//sys Fpathconf(fd int, name int) (val int, err error)

//sys Fstat(fd int, stat *Stat_t) (err error)

//sys Kqueue() (fd int, err error)

//sys Lchown(path string, uid int, gid int) (err error)

//sys Link(path string, link string) (err error)

//sys Listen(s int, backlog int) (err error)

//sys Lstat(path string, stat *Stat_t) (err error)

//sys Mkdir(path string, mode uint32) (err error)

//sys Mkfifo(path string, mode uint32) (err error)

//sys Mknod(path string, mode uint32, dev int) (err error)

//sys Nanosleep(time *Timespec, leftover *Timespec) (err error)

//sys Open(path string, mode int, perm uint32) (fd int, err error)

//sys Pathconf(path string, name int) (val int, err error)

//sys Pread(fd int, p []byte, offset int64) (n int, err error)

//sys Pwrite(fd int, p []byte, offset int64) (n int, err error)

//sys read(fd int, p []byte) (n int, err error)

//sys Readlink(path string, buf []byte) (n int, err error)

//sys Rename(from string, to string) (err error)

//sys Revoke(path string) (err error)

//sys Rmdir(path string) (err error)

//sys Seek(fd int, offset int64, whence int) (newoffset int64, err error) = SYS_LSEEK

//sys Stat(path string, stat *Stat_t) (err error)

//sys Statfs(path string, stat *Statfs_t) (err error)

//sys Symlink(path string, link string) (err error)

//sys Sync() (err error)

//sys Truncate(path string, length int64) (err error)

//sys Umask(newmask int) (oldmask int)

//sys Undelete(path string) (err error)

//sys Unlink(path string) (err error)

//sys Unmount(path string, flags int) (err error)

//sys write(fd int, p []byte) (n int, err error)

//sys mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)

//sys readlen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_READ

//sys writelen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_WRITE

//sys accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int, err error)

/*

* Unimplemented

// Add_profil

// Kdebug_trace

// Sigreturn

// Atsocket

// Kqueue_from_portset_np

// Kqueue_portset

// Searchfs

// Delete

// Copyfile

// Watchevent

// Waitevent

// Modwatch

// Lio_listio

// __pthread_cond_wait

// Iopolicysys

// __pthread_kill

// __pthread_sigmask

// __sigwait

// Sendmsg_nocancel

// Recvfrom_nocancel

// Accept_nocancel

// Fcntl_nocancel

// Select_nocancel

// Fsync_nocancel

"unsafe"

)

}

}

func SetKevent(k *Kevent_t, fd, mode, flags int) {

"unsafe"

)

}

}

func SetKevent(k *Kevent_t, fd, mode, flags int) {

"unsafe"

)

}

}

func SetKevent(k *Kevent_t, fd, mode, flags int) {

return Open(path, O_CREAT|O_WRONLY|O_TRUNC, mode)

}

//sys Linkat(olddirfd int, oldpath string, newdirfd int, newpath string, flags int) (err error)

func Link(oldpath string, newpath string) (err error) {

return nil, nil

}

if n < 0 || n > 1<<20 {

return nil, EINVAL

}

// 0x7F (stopped), or a signal number that caused an exit.

// The 0x80 bit is whether there was a core dump.

// An extra number (exit code, signal causing a stop)

// "continued" status is 0xFFFF, distinguishing itself

// from stopped via the core dump bit.

return

}

return Mknod(path, mode|S_IFIFO, 0)

}

func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {

if sa.Port < 0 || sa.Port > 0xFFFF {

return nil, 0, EINVAL

return unsafe.Pointer(&sa.raw), SizeofSockaddrALG, nil

}

func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, error) {

switch rsa.Addr.Family {

case AF_NETLINK:

sa.Addr[i] = pp.Addr[i]

}

return sa, nil

}

return nil, EAFNOSUPPORT

}

return &value, err

}

func SetsockoptIPMreqn(fd, level, opt int, mreq *IPMreqn) (err error) {

return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))

}

func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) {

var msg Msghdr

var rsa RawSockaddrAny

msg.Namelen = uint32(SizeofSockaddrAny)

var iov Iovec

if len(p) > 0 {

iov.SetLen(len(p))

}

var dummy byte

if len(oob) > 0 {

// receive at least one normal byte

iov.Base = &dummy

iov.SetLen(1)

}

msg.SetControllen(len(oob))

}

msg.Iov = &iov

}

}

var msg Msghdr

msg.Namelen = uint32(salen)

var iov Iovec

if len(p) > 0 {

iov.SetLen(len(p))

}

var dummy byte

if len(oob) > 0 {

// send at least one normal byte

iov.Base = &dummy

iov.SetLen(1)

}

msg.SetControllen(len(oob))

}

msg.Iov = &iov

var buf [sizeofPtr]byte

// access (PEEKUSER warns that it might), but if we don't

// align our reads, we might straddle an unmapped page

// boundary and not get the bytes leading up to the page

return ptracePeek(PTRACE_PEEKDATA, pid, addr, out)

}

func ptracePoke(pokeReq int, peekReq int, pid int, addr uintptr, data []byte) (count int, err error) {

// As for ptracePeek, we need to align our accesses to deal

// with the possibility of straddling an invalid page.

return ptracePoke(PTRACE_POKEDATA, PTRACE_PEEKDATA, pid, addr, data)

}

func PtraceGetRegs(pid int, regsout *PtraceRegs) (err error) {

return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))

}

return reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, cmd, "")

}

func ReadDirent(fd int, buf []byte) (n int, err error) {

return Getdents(fd, buf)

}