func setxattr(path string, name string, value *byte, size int) (err error) {
_, _, e1 := syscall.Syscall6(syscall.SYS_SETXATTR,
uintptr(unsafe.Pointer(syscall.StringBytePtr(path))),
uintptr(unsafe.Pointer(syscall.StringBytePtr(name))),
uintptr(unsafe.Pointer(value)), uintptr(size), 0, 0)
return e1
}
func fight(w1 string, w2 string, rounds int) result {
r := result{}
f2w.Call(
uintptr(unsafe.Pointer(syscall.StringBytePtr(w1))),
uintptr(unsafe.Pointer(syscall.StringBytePtr(w2))),
uintptr(currentConfig.Mars.Coresize),
uintptr(currentConfig.Mars.Cycles),
uintptr(currentConfig.Mars.Maxprocess),
uintptr(rounds),
uintptr(currentConfig.Mars.Maxwarriorlen),
uintptr(currentConfig.Mars.FixedPos),
uintptr(unsafe.Pointer(&r.Win)),
uintptr(unsafe.Pointer(&r.Lose)),
uintptr(unsafe.Pointer(&r.Equal)))
fightMetrics++
roundsMetrics += rounds
if r.Equal+r.Lose+r.Win != rounds {
return result{0, 0, 0}
}
return r
}
func Removexattr(path string, attr string) (errno int) {
pathbs := syscall.StringBytePtr(path)
attrbs := syscall.StringBytePtr(attr)
_, _, errNo := syscall.Syscall(
syscall.SYS_REMOVEXATTR,
uintptr(unsafe.Pointer(pathbs)),
uintptr(unsafe.Pointer(attrbs)), 0)
return int(errNo)
}
func (file *File) readdirnames(n int) (names []string, err error) {
if elen == 0 {
var dummy syscall.Dirent
elen = (int(unsafe.Offsetof(dummy.Name)) +
libc_pathconf(syscall.StringBytePtr(file.name), syscall.PC_NAME_MAX) +
1)
}
if file.dirinfo == nil {
file.dirinfo = new(dirInfo)
file.dirinfo.buf = make([]byte, elen)
p := syscall.StringBytePtr(file.name)
syscall.Entersyscall()
r := libc_opendir(p)
syscall.Exitsyscall()
file.dirinfo.dir = r
}
entry_dirent := (*syscall.Dirent)(unsafe.Pointer(&file.dirinfo.buf[0]))
size := n
if size <= 0 {
size = 100
n = -1
}
names = make([]string, 0, size) // Empty with room to grow.
dir := file.dirinfo.dir
if dir == nil {
return names, NewSyscallError("opendir", syscall.GetErrno())
}
for n != 0 {
var result *syscall.Dirent
pr := &result
syscall.Entersyscall()
i := libc_readdir_r(dir, entry_dirent, pr)
syscall.Exitsyscall()
if i != 0 {
return names, NewSyscallError("readdir_r", i)
}
if result == nil {
break // EOF
}
var name = string(result.Name[0:clen(result.Name[0:])])
if name == "." || name == ".." { // Useless names
continue
}
names = append(names, name)
n--
}
if n >= 0 && len(names) == 0 {
return names, io.EOF
}
return names, nil
}
// int removexattr(const char *path, const char *name, int options);
func removexattr(path string, name string) (e error) {
_, _, e1 := syscall.Syscall(syscall.SYS_REMOVEXATTR,
uintptr(unsafe.Pointer(syscall.StringBytePtr(path))),
uintptr(unsafe.Pointer(syscall.StringBytePtr(name))),
0)
if e1 != noError {
e = e1
}
return
}
func getxattr(path string, attr string, dest []byte) (sz int, errno int) {
pathBs := syscall.StringBytePtr(path)
attrBs := syscall.StringBytePtr(attr)
size, _, errNo := syscall.Syscall6(
syscall.SYS_GETXATTR,
uintptr(unsafe.Pointer(pathBs)),
uintptr(unsafe.Pointer(attrBs)),
uintptr(unsafe.Pointer(&dest[0])),
uintptr(len(dest)),
0, 0)
return int(size), int(errNo)
}
// ssize_t getxattr(const char *path, const char *name, void *value, size_t size, u_int32_t position, int options);
func getxattr(path string, name string, value *byte, size int) (resSize int, e error) {
r0, _, e1 := syscall.Syscall6(syscall.SYS_GETXATTR,
uintptr(unsafe.Pointer(syscall.StringBytePtr(path))),
uintptr(unsafe.Pointer(syscall.StringBytePtr(name))),
uintptr(unsafe.Pointer(value)),
uintptr(size), 0, 0)
resSize = int(r0)
if e1 != noError {
e = e1
}
return
}
func getxattr(path string, name string, value *byte, size int) (int, error) {
if r0, _, e1 := syscall.Syscall6(syscall.SYS_GETXATTR,
uintptr(unsafe.Pointer(syscall.StringBytePtr(path))),
uintptr(unsafe.Pointer(syscall.StringBytePtr(name))),
uintptr(unsafe.Pointer(value)), uintptr(size), 0, 0); e1 != syscall.Errno(0) {
if e1 == syscall.ENODATA {
return 0, e1
}
return -1, e1
} else {
return int(r0), nil
}
}
func Setxattr(path string, attr string, data []byte, flags int) (errno int) {
pathbs := syscall.StringBytePtr(path)
attrbs := syscall.StringBytePtr(attr)
_, _, errNo := syscall.Syscall6(
syscall.SYS_SETXATTR,
uintptr(unsafe.Pointer(pathbs)),
uintptr(unsafe.Pointer(attrbs)),
uintptr(unsafe.Pointer(&data[0])),
uintptr(len(data)),
uintptr(flags), 0)
return int(errNo)
}
func Linkat(fd1 int, n1 string, fd2 int, n2 string) int {
b1 := syscall.StringBytePtr(n1)
b2 := syscall.StringBytePtr(n2)
_, _, errNo := syscall.Syscall6(
syscall.SYS_LINKAT,
uintptr(fd1),
uintptr(unsafe.Pointer(b1)),
uintptr(fd2),
uintptr(unsafe.Pointer(b2)),
0, 0)
return int(errNo)
}
func main() {
if len(os.Args) != 2 {
fmt.Printf("Usage: gogo file.go\n")
return
}
var r0 uintptr
var e1 uintptr
var e int
var fd uint64
var errno uint64
r0, _, e1 = syscall.Syscall(syscall.SYS_OPEN, uintptr(unsafe.Pointer(syscall.StringBytePtr(os.Args[1]))), 0, 0)
e = int(e1)
fd = uint64(r0)
if e == 0 {
ScannerTest(fd)
errno = libgogo.FileClose(fd)
if errno != 0 {
libgogo.ExitError("Error closing file", errno)
}
} else {
fmt.Printf("Error opening file %s.\n", os.Args[1])
}
}
func WglGetProcAddress(szProc string) uintptr {
ret, _, _ := procwglGetProcAddress.Call(
uintptr(unsafe.Pointer(syscall.StringBytePtr(szProc))),
)
return ret
}
// Open opens an asynchronous communications port.
func Open(name string, options ...func(*Term) error) (*Term, error) {
fd, e := syscall.Open(name, syscall.O_NOCTTY|syscall.O_CLOEXEC|syscall.O_NDELAY|syscall.O_RDWR, 0666)
if e != nil {
return nil, &os.PathError{"open", name, e}
}
modules := [2]string{"ptem", "ldterm"}
for _, mod := range modules {
err := unix.IoctlSetInt(fd, C.I_PUSH, int(uintptr(unsafe.Pointer(syscall.StringBytePtr(mod)))))
if err != nil {
return nil, err
}
}
t := Term{name: name, fd: fd}
termios.Tcgetattr(uintptr(t.fd), &t.orig)
if err := termios.Tcgetattr(uintptr(t.fd), &t.orig); err != nil {
return nil, err
}
if err := t.SetOption(options...); err != nil {
return nil, err
}
return &t, syscall.SetNonblock(t.fd, false)
}
func lookupUser(username string) (*User, error) {
var pwd syscall.Passwd
var result *syscall.Passwd
p := syscall.StringBytePtr(username)
buf := alloc(userBuffer)
defer buf.free()
err := retryWithBuffer(buf, func() syscall.Errno {
syscall.Entersyscall()
rv := libc_getpwnam_r(p,
&pwd,
buf.ptr,
buf.size,
&result)
syscall.Exitsyscall()
if rv != 0 {
return syscall.GetErrno()
}
return 0
})
if err != nil {
return nil, fmt.Errorf("user: lookup username %s: %v", username, err)
}
if result == nil {
return nil, UnknownUserError(username)
}
return buildUser(&pwd), err
}
func lookupGroup(groupname string) (*Group, error) {
var grp syscall.Group
var result *syscall.Group
buf := alloc(groupBuffer)
defer buf.free()
p := syscall.StringBytePtr(groupname)
err := retryWithBuffer(buf, func() syscall.Errno {
syscall.Entersyscall()
rv := libc_getgrnam_r(p,
&grp,
buf.ptr,
buf.size,
&result)
syscall.Exitsyscall()
if rv != 0 {
return syscall.GetErrno()
}
return 0
})
if err != nil {
return nil, fmt.Errorf("user: lookup groupname %s: %v", groupname, err)
}
if result == nil {
return nil, UnknownGroupError(groupname)
}
return buildGroup(&grp), nil
}
func cgoLookupPort(network, service string) (port int, err error, completed bool) {
acquireThread()
defer releaseThread()
var hints syscall.Addrinfo
switch network {
case "": // no hints
case "tcp", "tcp4", "tcp6":
hints.Ai_socktype = syscall.SOCK_STREAM
hints.Ai_protocol = syscall.IPPROTO_TCP
case "udp", "udp4", "udp6":
hints.Ai_socktype = syscall.SOCK_DGRAM
hints.Ai_protocol = syscall.IPPROTO_UDP
default:
return 0, &DNSError{Err: "unknown network", Name: network + "/" + service}, true
}
if len(network) >= 4 {
switch network[3] {
case '4':
hints.Ai_family = syscall.AF_INET
case '6':
hints.Ai_family = syscall.AF_INET6
}
}
s := syscall.StringBytePtr(service)
var res *syscall.Addrinfo
syscall.Entersyscall()
gerrno := libc_getaddrinfo(nil, s, &hints, &res)
syscall.Exitsyscall()
if gerrno != 0 {
switch gerrno {
case syscall.EAI_SYSTEM:
errno := syscall.GetErrno()
if errno == 0 { // see golang.org/issue/6232
errno = syscall.EMFILE
}
err = errno
default:
err = addrinfoErrno(gerrno)
}
return 0, &DNSError{Err: err.Error(), Name: network + "/" + service}, true
}
defer libc_freeaddrinfo(res)
for r := res; r != nil; r = r.Ai_next {
switch r.Ai_family {
case syscall.AF_INET:
sa := (*syscall.RawSockaddrInet4)(unsafe.Pointer(r.Ai_addr))
p := (*[2]byte)(unsafe.Pointer(&sa.Port))
return int(p[0])<<8 | int(p[1]), nil, true
case syscall.AF_INET6:
sa := (*syscall.RawSockaddrInet6)(unsafe.Pointer(r.Ai_addr))
p := (*[2]byte)(unsafe.Pointer(&sa.Port))
return int(p[0])<<8 | int(p[1]), nil, true
}
}
return 0, &DNSError{Err: "unknown port", Name: network + "/" + service}, true
}
func removexattr(path string, name string) (err error) {
_, _, e1 := syscall.Syscall(syscall.SYS_REMOVEXATTR, uintptr(unsafe.Pointer(syscall.StringBytePtr(path))), uintptr(unsafe.Pointer(syscall.StringBytePtr(name))), 0)
//var err error = nil
if e1 != 0 {
err = e1
}
return e1
}
func removexattr(path string, name string, options int) error {
_, _, e1 := syscall.Syscall(syscall.SYS_REMOVEXATTR, uintptr(unsafe.Pointer(syscall.StringBytePtr(path))), uintptr(unsafe.Pointer(syscall.StringBytePtr(name))), uintptr(options))
var err error = nil
if e1 != 0 {
err = e1
}
return err
}
func listxattr(path string, namebuf *byte, size int, options int) (int, error) {
r0, _, e1 := syscall.Syscall6(syscall.SYS_LISTXATTR, uintptr(unsafe.Pointer(syscall.StringBytePtr(path))), uintptr(unsafe.Pointer(namebuf)), uintptr(size), uintptr(options), 0, 0)
var err error = nil
if e1 != 0 {
err = e1
}
return int(r0), err
}
func getxattr(path string, name string, value *byte, size int, pos int, options int) (int, error) {
r0, _, e1 := syscall.Syscall6(syscall.SYS_GETXATTR, uintptr(unsafe.Pointer(syscall.StringBytePtr(path))), uintptr(unsafe.Pointer(syscall.StringBytePtr(name))), uintptr(unsafe.Pointer(value)), uintptr(size), uintptr(pos), uintptr(options))
var err error = nil
if e1 != 0 {
err = e1
}
return int(r0), err
}
func (conn sqlaConn) executeDirect(query string) (_ sqlaStmt, err error) {
ret, _, _ := sqlany_execute_direct.Call(uintptr(conn),
uintptr(unsafe.Pointer(syscall.StringBytePtr(query))))
if ret == 0 {
err = conn.newError()
return sqlaStmt(0), err
}
return sqlaStmt(ret), nil
}
func Init() {
lib := loadLibrary("opengl32.dll")
wglGetProcAddress := getProcAddress(lib, "wglGetProcAddress")
wglSwapIntervalEXT, _, _ = syscall.Syscall(wglGetProcAddress, 1,
uintptr(unsafe.Pointer(syscall.StringBytePtr("wglSwapIntervalEXT"))),
0,
0)
}
func listxattr(path string, dest []byte) (sz int, errno int) {
pathbs := syscall.StringBytePtr(path)
size, _, errNo := syscall.Syscall(
syscall.SYS_LISTXATTR,
uintptr(unsafe.Pointer(pathbs)),
uintptr(unsafe.Pointer(&dest[0])),
uintptr(len(dest)))
return int(size), int(errNo)
}
func (conn sqlaConn) connect(opts string) (err error) {
ret, _, _ := sqlany_connect.Call(uintptr(conn),
uintptr(unsafe.Pointer(syscall.StringBytePtr(opts))))
if ret != 1 {
code, msg := conn.queryError()
err = &sqlaError{code: code, msg: msg}
return
}
return nil
}
func listxattr(path string, namebuf *byte, size int) (int, error) {
if r0, _, e1 := syscall.Syscall(syscall.SYS_LISTXATTR,
uintptr(unsafe.Pointer(syscall.StringBytePtr(path))),
uintptr(unsafe.Pointer(namebuf)),
uintptr(size)); e1 != syscall.Errno(0) {
return -1, e1
} else {
return int(r0), nil
}
}
func TestCDecl(t *testing.T) {
var buf [50]byte
a, _, _ := GetDLL(t, "user32.dll").Proc("wsprintfA").Call(
uintptr(unsafe.Pointer(&buf[0])),
uintptr(unsafe.Pointer(syscall.StringBytePtr("%d %d %d"))),
1000, 2000, 3000)
if string(buf[:a]) != "1000 2000 3000" {
t.Error("cdecl USER32.wsprintfA returns", a, "buf=", buf[:a])
}
}
func cgoLookupIPCNAME(name string) (addrs []IP, cname string, err error, completed bool) {
var res *syscall.Addrinfo
var hints syscall.Addrinfo
// NOTE(rsc): In theory there are approximately balanced
// arguments for and against including AI_ADDRCONFIG
// in the flags (it includes IPv4 results only on IPv4 systems,
// and similarly for IPv6), but in practice setting it causes
// getaddrinfo to return the wrong canonical name on Linux.
// So definitely leave it out.
hints.Ai_flags = int32((syscall.AI_ALL | syscall.AI_V4MAPPED | syscall.AI_CANONNAME) & cgoAddrInfoMask())
h := syscall.StringBytePtr(name)
syscall.Entersyscall()
gerrno := libc_getaddrinfo(h, nil, &hints, &res)
syscall.Exitsyscall()
if gerrno != 0 {
var str string
if gerrno == syscall.EAI_NONAME {
str = noSuchHost
} else if gerrno == syscall.EAI_SYSTEM {
str = syscall.GetErrno().Error()
} else {
str = bytePtrToString(libc_gai_strerror(gerrno))
}
return nil, "", &DNSError{Err: str, Name: name}, true
}
defer libc_freeaddrinfo(res)
if res != nil {
cname = bytePtrToString((*byte)(unsafe.Pointer(res.Ai_canonname)))
if cname == "" {
cname = name
}
if len(cname) > 0 && cname[len(cname)-1] != '.' {
cname += "."
}
}
for r := res; r != nil; r = r.Ai_next {
// Everything comes back twice, once for UDP and once for TCP.
if r.Ai_socktype != syscall.SOCK_STREAM {
continue
}
switch r.Ai_family {
default:
continue
case syscall.AF_INET:
sa := (*syscall.RawSockaddrInet4)(unsafe.Pointer(r.Ai_addr))
addrs = append(addrs, copyIP(sa.Addr[:]))
case syscall.AF_INET6:
sa := (*syscall.RawSockaddrInet6)(unsafe.Pointer(r.Ai_addr))
addrs = append(addrs, copyIP(sa.Addr[:]))
}
}
return addrs, cname, nil, true
}
// Negative count means read until EOF.
func (file *File) Readdirnames(count int) (names []string, err Error) {
if elen == 0 {
var dummy syscall.Dirent;
elen = (unsafe.Offsetof(dummy.Name) +
libc_pathconf(syscall.StringBytePtr(file.name), syscall.PC_NAME_MAX) +
1);
}
if file.dirinfo == nil {
file.dirinfo = new(dirInfo)
file.dirinfo.buf = make([]byte, elen)
file.dirinfo.dir = libc_opendir(syscall.StringBytePtr(file.name))
}
entry_dirent := unsafe.Pointer(&file.dirinfo.buf[0]).(*syscall.Dirent)
size := count
if size < 0 {
size = 100
}
names = make([]string, 0, size) // Empty with room to grow.
dir := file.dirinfo.dir
if dir == nil {
return names, NewSyscallError("opendir", syscall.GetErrno())
}
for count != 0 {
var result *syscall.Dirent
i := libc_readdir_r(dir, entry_dirent, &result)
if result == nil {
break
}
var name = string(result.Name[0:clen(result.Name[0:])])
if name == "." || name == ".." { // Useless names
continue
}
count--
names = append(names, name)
}
return names, nil
}
// ssize_t listxattr(const char *path, char *namebuf, size_t size, int options);
func listxattr(path string, namebuf *byte, size int) (resSize int, e error) {
r0, _, e1 := syscall.Syscall(syscall.SYS_LISTXATTR,
uintptr(unsafe.Pointer(syscall.StringBytePtr(path))),
uintptr(unsafe.Pointer(namebuf)),
uintptr(size))
resSize = int(r0)
if e1 != noError {
e = e1
}
return
}
func lookupUnix(uid int, username string, lookupByName bool) (*User, error) {
var pwd syscall.Passwd
var result *syscall.Passwd
// FIXME: Should let buf grow if necessary.
const bufSize = 1024
buf := make([]byte, bufSize)
if lookupByName {
nameC := syscall.StringBytePtr(username)
syscall.Entersyscall()
rv := libc_getpwnam_r(nameC,
&pwd,
&buf[0],
bufSize,
&result)
syscall.Exitsyscall()
if rv != 0 {
return nil, fmt.Errorf("user: lookup username %s: %s", username, syscall.GetErrno())
}
if result == nil {
return nil, UnknownUserError(username)
}
} else {
syscall.Entersyscall()
rv := libc_getpwuid_r(syscall.Uid_t(uid),
&pwd,
&buf[0],
bufSize,
&result)
syscall.Exitsyscall()
if rv != 0 {
return nil, fmt.Errorf("user: lookup userid %d: %s", uid, syscall.GetErrno())
}
if result == nil {
return nil, UnknownUserIdError(uid)
}
}
u := &User{
Uid: strconv.Itoa(int(pwd.Pw_uid)),
Gid: strconv.Itoa(int(pwd.Pw_gid)),
Username: bytePtrToString((*byte)(unsafe.Pointer(pwd.Pw_name))),
Name: bytePtrToString((*byte)(unsafe.Pointer(pwd.Pw_gecos))),
HomeDir: bytePtrToString((*byte)(unsafe.Pointer(pwd.Pw_dir))),
}
// The pw_gecos field isn't quite standardized. Some docs
// say: "It is expected to be a comma separated list of
// personal data where the first item is the full name of the
// user."
if i := strings.Index(u.Name, ","); i >= 0 {
u.Name = u.Name[:i]
}
return u, nil
}