blob: f99c2a198ecd7d01e4524f008d7af14765374bc9 [file] [log] [blame]
// Copyright 2017 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.
//go:build solaris
// +build solaris
package unix_test
import (
"fmt"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"testing"
"golang.org/x/sys/unix"
)
// getOneRetry wraps EventPort.GetOne which in turn wraps a syscall that can be
// interrupted causing us to receive EINTR.
// To prevent our tests from flaking, we retry the syscall until it works
// rather than get unexpected results in our tests.
func getOneRetry(t *testing.T, p *unix.EventPort, timeout *unix.Timespec) (e *unix.PortEvent, err error) {
t.Helper()
for {
e, err = p.GetOne(timeout)
if err != unix.EINTR {
break
}
}
return e, err
}
// getRetry wraps EventPort.Get which in turn wraps a syscall that can be
// interrupted causing us to receive EINTR.
// To prevent our tests from flaking, we retry the syscall until it works
// rather than get unexpected results in our tests.
func getRetry(t *testing.T, p *unix.EventPort, s []unix.PortEvent, min int, timeout *unix.Timespec) (n int, err error) {
t.Helper()
for {
n, err = p.Get(s, min, timeout)
if err != unix.EINTR {
break
}
// If we did get EINTR, make sure we got 0 events
if n != 0 {
t.Fatalf("EventPort.Get returned events on EINTR.\ngot: %d\nexpected: 0", n)
}
}
return n, err
}
func TestStatvfs(t *testing.T) {
if err := unix.Statvfs("", nil); err == nil {
t.Fatal(`Statvfs("") expected failure`)
}
statvfs := unix.Statvfs_t{}
if err := unix.Statvfs("/", &statvfs); err != nil {
t.Errorf(`Statvfs("/") failed: %v`, err)
}
if t.Failed() {
mount, err := exec.Command("mount").CombinedOutput()
if err != nil {
t.Logf("mount: %v\n%s", err, mount)
} else {
t.Logf("mount: %s", mount)
}
}
}
func TestSysconf(t *testing.T) {
n, err := unix.Sysconf(3 /* SC_CLK_TCK */)
if err != nil {
t.Fatalf("Sysconf: %v", err)
}
t.Logf("Sysconf(SC_CLK_TCK) = %d", n)
}
// Event Ports
func TestBasicEventPort(t *testing.T) {
tmpfile, err := os.Create(filepath.Join(t.TempDir(), "eventport"))
if err != nil {
t.Fatal(err)
}
defer tmpfile.Close()
path := tmpfile.Name()
stat, err := os.Stat(path)
if err != nil {
t.Fatalf("Failed to stat %s: %v", path, err)
}
port, err := unix.NewEventPort()
if err != nil {
t.Fatalf("NewEventPort failed: %v", err)
}
defer port.Close()
cookie := stat.Mode()
err = port.AssociatePath(path, stat, unix.FILE_MODIFIED, cookie)
if err != nil {
t.Errorf("AssociatePath failed: %v", err)
}
if !port.PathIsWatched(path) {
t.Errorf("PathIsWatched unexpectedly returned false")
}
err = port.DissociatePath(path)
if err != nil {
t.Errorf("DissociatePath failed: %v", err)
}
err = port.AssociatePath(path, stat, unix.FILE_MODIFIED, cookie)
if err != nil {
t.Errorf("AssociatePath failed: %v", err)
}
bs := []byte{42}
tmpfile.Write(bs)
timeout := new(unix.Timespec)
timeout.Nsec = 100
pevent, err := getOneRetry(t, port, timeout)
if err == unix.ETIME {
t.Errorf("GetOne timed out: %v", err)
}
if err != nil {
t.Fatalf("GetOne failed: %v", err)
}
if pevent.Path != path {
t.Errorf("Path mismatch: %v != %v", pevent.Path, path)
}
err = port.AssociatePath(path, stat, unix.FILE_MODIFIED, cookie)
if err != nil {
t.Errorf("AssociatePath failed: %v", err)
}
err = port.AssociatePath(path, stat, unix.FILE_MODIFIED, cookie)
if err == nil {
t.Errorf("Unexpected success associating already associated path")
}
}
func TestEventPortFds(t *testing.T) {
_, path, _, _ := runtime.Caller(0)
stat, err := os.Stat(path)
cookie := stat.Mode()
port, err := unix.NewEventPort()
if err != nil {
t.Errorf("NewEventPort failed: %v", err)
}
defer port.Close()
r, w, err := os.Pipe()
if err != nil {
t.Errorf("unable to create a pipe: %v", err)
}
defer w.Close()
defer r.Close()
fd := r.Fd()
port.AssociateFd(fd, unix.POLLIN, cookie)
if !port.FdIsWatched(fd) {
t.Errorf("FdIsWatched unexpectedly returned false")
}
err = port.DissociateFd(fd)
err = port.AssociateFd(fd, unix.POLLIN, cookie)
bs := []byte{42}
w.Write(bs)
n, err := port.Pending()
if n != 1 {
t.Errorf("Pending() failed: %v, %v", n, err)
}
timeout := new(unix.Timespec)
timeout.Nsec = 100
pevent, err := getOneRetry(t, port, timeout)
if err == unix.ETIME {
t.Errorf("GetOne timed out: %v", err)
}
if err != nil {
t.Fatalf("GetOne failed: %v", err)
}
if pevent.Fd != fd {
t.Errorf("Fd mismatch: %v != %v", pevent.Fd, fd)
}
var c = pevent.Cookie
if c == nil {
t.Errorf("Cookie missing: %v != %v", cookie, c)
return
}
if c != cookie {
t.Errorf("Cookie mismatch: %v != %v", cookie, c)
}
port.AssociateFd(fd, unix.POLLIN, cookie)
err = port.AssociateFd(fd, unix.POLLIN, cookie)
if err == nil {
t.Errorf("unexpected success associating already associated fd")
}
}
func TestEventPortErrors(t *testing.T) {
tmpfile, err := os.CreateTemp("", "eventport")
if err != nil {
t.Errorf("unable to create a tempfile: %v", err)
}
path := tmpfile.Name()
stat, _ := os.Stat(path)
os.Remove(path)
port, _ := unix.NewEventPort()
defer port.Close()
err = port.AssociatePath(path, stat, unix.FILE_MODIFIED, nil)
if err == nil {
t.Errorf("unexpected success associating nonexistant file")
}
err = port.DissociatePath(path)
if err == nil {
t.Errorf("unexpected success dissociating unassociated path")
}
timeout := new(unix.Timespec)
timeout.Nsec = 1
_, err = getOneRetry(t, port, timeout)
if err != unix.ETIME {
t.Errorf("port.GetOne(%v) returned error %v, want %v", timeout, err, unix.ETIME)
}
err = port.DissociateFd(uintptr(0))
if err == nil {
t.Errorf("unexpected success dissociating unassociated fd")
}
events := make([]unix.PortEvent, 4)
_, err = getRetry(t, port, events, 5, nil)
if err == nil {
t.Errorf("unexpected success calling Get with min greater than len of slice")
}
_, err = getRetry(t, port, nil, 1, nil)
if err == nil {
t.Errorf("unexpected success calling Get with nil slice")
}
_, err = getRetry(t, port, nil, 0, nil)
if err == nil {
t.Errorf("unexpected success calling Get with nil slice")
}
}
func ExamplePortEvent() {
type MyCookie struct {
Name string
}
cookie := MyCookie{"Cookie Monster"}
port, err := unix.NewEventPort()
if err != nil {
fmt.Printf("NewEventPort failed: %v\n", err)
return
}
defer port.Close()
r, w, err := os.Pipe()
if err != nil {
fmt.Printf("os.Pipe() failed: %v\n", err)
return
}
defer w.Close()
defer r.Close()
fd := r.Fd()
port.AssociateFd(fd, unix.POLLIN, cookie)
bs := []byte{42}
w.Write(bs)
timeout := new(unix.Timespec)
timeout.Sec = 1
var pevent *unix.PortEvent
for {
pevent, err = port.GetOne(timeout)
if err != unix.EINTR {
break
}
}
if err != nil {
fmt.Printf("didn't get the expected event: %v\n", err)
}
// Use a type assertion to convert the received cookie back to its original type
c := pevent.Cookie.(MyCookie)
fmt.Printf("%s", c.Name)
//Output: Cookie Monster
}
func TestPortEventSlices(t *testing.T) {
port, err := unix.NewEventPort()
if err != nil {
t.Fatalf("NewEventPort failed: %v", err)
}
// Create, associate, and delete 6 files
for i := 0; i < 6; i++ {
tmpfile, err := os.CreateTemp("", "eventport")
if err != nil {
t.Fatalf("unable to create tempfile: %v", err)
}
path := tmpfile.Name()
stat, err := os.Stat(path)
if err != nil {
t.Fatalf("unable to stat tempfile: %v", err)
}
err = port.AssociatePath(path, stat, unix.FILE_MODIFIED, nil)
if err != nil {
t.Fatalf("unable to AssociatePath tempfile: %v", err)
}
err = os.Remove(path)
if err != nil {
t.Fatalf("unable to Remove tempfile: %v", err)
}
}
n, err := port.Pending()
if err != nil {
t.Errorf("Pending failed: %v", err)
}
if n != 6 {
t.Errorf("expected 6 pending events, got %d", n)
}
timeout := new(unix.Timespec)
timeout.Nsec = 1
events := make([]unix.PortEvent, 4)
n, err = getRetry(t, port, events, 3, timeout)
if err != nil {
t.Errorf("Get failed: %v", err)
}
if n != 4 {
t.Errorf("expected 4 events, got %d", n)
}
e := events[:n]
for _, p := range e {
if p.Events != unix.FILE_DELETE {
t.Errorf("unexpected event. got %v, expected %v", p.Events, unix.FILE_DELETE)
}
}
n, err = getRetry(t, port, events, 3, timeout)
if err != unix.ETIME {
t.Errorf("unexpected error. got %v, expected %v", err, unix.ETIME)
}
if n != 2 {
t.Errorf("expected 2 events, got %d", n)
}
e = events[:n]
for _, p := range e {
if p.Events != unix.FILE_DELETE {
t.Errorf("unexpected event. got %v, expected %v", p.Events, unix.FILE_DELETE)
}
}
r, w, err := os.Pipe()
if err != nil {
t.Fatalf("unable to create a pipe: %v", err)
}
port.AssociateFd(r.Fd(), unix.POLLIN, nil)
port.AssociateFd(w.Fd(), unix.POLLOUT, nil)
bs := []byte{41}
w.Write(bs)
n, err = getRetry(t, port, events, 1, timeout)
if err != nil {
t.Errorf("Get failed: %v", err)
}
if n != 2 {
t.Errorf("expected 2 events, got %d", n)
}
err = w.Close()
if err != nil {
t.Errorf("w.Close() failed: %v", err)
}
err = r.Close()
if err != nil {
t.Errorf("r.Close() failed: %v", err)
}
err = port.Close()
if err != nil {
t.Errorf("port.Close() failed: %v", err)
}
}
func TestLifreqSetName(t *testing.T) {
var l unix.Lifreq
err := l.SetName("12345678901234356789012345678901234567890")
if err == nil {
t.Fatal(`Lifreq.SetName should reject names that are too long`)
}
err = l.SetName("tun0")
if err != nil {
t.Errorf(`Lifreq.SetName("tun0") failed: %v`, err)
}
}
func TestLifreqGetMTU(t *testing.T) {
// Find links and their MTU using CLI tooling
// $ dladm show-link -p -o link,mtu
// net0:1500
out, err := exec.Command("dladm", "show-link", "-p", "-o", "link,mtu").Output()
if err != nil {
t.Fatalf("unable to use dladm to find data links: %v", err)
}
lines := strings.Split(string(out), "\n")
tc := make(map[string]string)
for _, line := range lines {
v := strings.Split(line, ":")
if len(v) == 2 {
tc[v[0]] = v[1]
}
}
ip_fd, err := unix.Socket(unix.AF_INET, unix.SOCK_DGRAM, 0)
if err != nil {
t.Fatalf("could not open udp socket: %v", err)
}
var l unix.Lifreq
for link, mtu := range tc {
err = l.SetName(link)
if err != nil {
t.Fatalf("Lifreq.SetName(%q) failed: %v", link, err)
}
if err = unix.IoctlLifreq(ip_fd, unix.SIOCGLIFMTU, &l); err != nil {
t.Fatalf("unable to SIOCGLIFMTU: %v", err)
}
m := l.GetLifruUint()
if fmt.Sprintf("%d", m) != mtu {
t.Errorf("unable to read MTU correctly: expected %s, got %d", mtu, m)
}
}
}