// Attr returns the attributes of a given node.
func (s *Node) Attr(ctx context.Context, a *fuse.Attr) error {
log.Debug("Node attr")
if s.cached == nil {
if err := s.loadData(); err != nil {
return fmt.Errorf("readonly: loadData() failed: %s", err)
}
}
switch s.cached.GetType() {
case ftpb.Data_Directory:
a.Mode = os.ModeDir | 0555
a.Uid = uint32(os.Getuid())
a.Gid = uint32(os.Getgid())
case ftpb.Data_File:
size := s.cached.GetFilesize()
a.Mode = 0444
a.Size = uint64(size)
a.Blocks = uint64(len(s.Nd.Links))
a.Uid = uint32(os.Getuid())
a.Gid = uint32(os.Getgid())
case ftpb.Data_Raw:
a.Mode = 0444
a.Size = uint64(len(s.cached.GetData()))
a.Blocks = uint64(len(s.Nd.Links))
a.Uid = uint32(os.Getuid())
a.Gid = uint32(os.Getgid())
case ftpb.Data_Symlink:
a.Mode = 0777 | os.ModeSymlink
a.Size = uint64(len(s.cached.GetData()))
a.Uid = uint32(os.Getuid())
a.Gid = uint32(os.Getgid())
default:
return fmt.Errorf("Invalid data type - %s", s.cached.GetType())
}
return nil
}
func main() {
flagUsername := flag.String("username", "nobody", "username for the unprivileged child")
isChild, r, w, _, err := privsep.MaybeBecomeChild()
if err != nil {
log.Fatalf("MaybeBecomeChild failed: %s", err)
}
who := "parent"
if isChild {
who = "child"
}
log.Printf("%s: pid=%d uid=%d euid=%d gid=%d egid=%d",
who, os.Getpid(), os.Getuid(), os.Geteuid(), os.Getgid(), os.Getegid())
if isChild {
child(r, w)
return
}
if os.Getuid() != 0 {
log.Print("Warning: this example only works when run as the root user")
}
_, r, w, err = privsep.CreateChild(*flagUsername, os.Args[0], nil, nil)
if err != nil {
log.Fatalf("CreateChild failed: %s", err)
}
parent(r, w)
}
func TestSemStat(t *testing.T) {
semSetup(t)
defer semTeardown(t)
// EIDRM with a bad semset id
if _, err := (&SemaphoreSet{5, 2}).Stat(); err != syscall.EIDRM {
t.Error("semctl(IPC_STAT) on a made up semset id should fail")
}
info, err := ss.Stat()
if err != nil {
t.Fatal(err)
}
if info.Perms.OwnerUID != os.Getuid() {
t.Error("wrong owner uid", info.Perms.OwnerUID)
}
if info.Perms.CreatorUID != os.Getuid() {
t.Error("wrong creator uid", info.Perms.CreatorUID)
}
if info.Perms.Mode&0777 != 0600 {
t.Error("wrong mode", info.Perms.Mode)
}
if info.Count != 4 {
t.Error("wrong count", info.Count)
}
}
func (t *unixTransport) Auth() error {
cred := syscall.UnixCredentials(&syscall.Ucred{
Pid: int32(os.Getpid()),
Uid: uint32(os.Getuid()),
Gid: uint32(os.Getgid()),
})
_, _, err := t.WriteMsgUnix([]byte{0}, cred, nil)
if err != nil {
return err
}
if _, err := fmt.Fprintf(t, "AUTH EXTERNAL %x\r\n", fmt.Sprintf("%d", os.Getuid())); err != nil {
return err
}
var code, cookie string
if _, err := fmt.Fscanln(t, &code, &cookie); err != nil {
return err
}
fmt.Println(code, cookie)
if _, err := fmt.Fprintf(t, "BEGIN\r\n"); err != nil {
return err
}
return nil
}
func TestLink(t *testing.T) {
ino := maggiefs.NewInode(0, maggiefs.FTYPE_REG, 0755, uint32(os.Getuid()), uint32(os.Getgid()))
id, err := testCluster.Names.AddInode(ino)
if err != nil {
panic(err)
}
ino.Inodeid = id
ino2 := maggiefs.NewInode(0, maggiefs.FTYPE_REG, 0755, uint32(os.Getuid()), uint32(os.Getgid()))
id, err = testCluster.Names.AddInode(ino)
if err != nil {
panic(err)
}
ino2.Inodeid = id
// test normal link
fmt.Println("linking")
err = testCluster.Names.Link(ino.Inodeid, ino2.Inodeid, "name", true)
if err != nil {
panic(err)
}
ino, err = testCluster.Names.GetInode(ino.Inodeid)
if err != nil {
panic(err)
}
if ino.Children["name"].Inodeid != ino2.Inodeid {
t.Fatalf("Didn't link properly!")
}
// test an unforced attempt to overwrite
// test overwriting forced
}
// Test running 'ls -l' with a symlink 'b' pointing to a file 'a'
func Test_l_File_Link2(t *testing.T) {
setup_test_dir("l_File_Link2")
time_now := time.Now()
size := 13
path := "a"
_mkfile2(path, 0600, os.Getuid(), os.Getgid(), size, time_now)
_mklink(path, "b")
var output_buffer bytes.Buffer
args := []string{"-l", "--nocolor"}
ls_err := ls(&output_buffer, args, tw)
output := clean_output_buffer(output_buffer)
// remove the permissions string from each file listing
output_line_split := strings.Split(output, "\n")
output_noperms := ""
for _, l := range output_line_split {
output_line_split_noperms := strings.Split(l, " ")[1:]
output_line_noperms := strings.Join(output_line_split_noperms, " ")
if len(output_noperms) == 0 {
output_noperms = output_line_noperms
} else {
output_noperms = output_noperms + "\n" + output_line_noperms
}
}
var owner string
owner_lookup, err := user.LookupId(fmt.Sprintf("%d", os.Getuid()))
if err != nil {
owner = user_map[int(os.Getuid())]
} else {
owner = owner_lookup.Username
}
group := group_map[os.Getgid()]
expected := fmt.Sprintf(
"1 %s %s %d %s %02d %02d:%02d a\n1 %s %s 1 %s %02d %02d:%02d b -> %s",
owner,
group,
size,
time_now.Month().String()[0:3],
time_now.Day(),
time_now.Hour(),
time_now.Minute(),
owner,
group,
time_now.Month().String()[0:3],
time_now.Day(),
time_now.Hour(),
time_now.Minute(),
path)
check_output(t, output_noperms, expected)
check_error_nil(t, ls_err)
}
func main() {
flagUsername := flag.String("username", "nobody", "username for the unprivileged child")
isChild, _, _, files, err := privsep.MaybeBecomeChild()
if err != nil {
log.Fatalf("MaybeBecomeChild failed: %s", err)
}
who := "parent"
if isChild {
who = "child"
}
log.Printf("%s: pid=%d uid=%d euid=%d gid=%d egid=%d",
who, os.Getpid(), os.Getuid(), os.Geteuid(), os.Getgid(), os.Getegid())
if isChild {
if len(files) < 1 {
log.Fatalf("no extra files: %v", files)
}
l, err := net.FileListener(files[0])
if err != nil {
log.Fatalf("FileListener: %s", err)
}
child(l)
return
}
if os.Getuid() != 0 {
log.Print("Warning: this example only works when run as the root user")
}
addr := "localhost:1111"
laddr, err := net.ResolveTCPAddr("tcp", addr)
if err != nil {
log.Fatalf("resolve %s: %s", addr, err)
}
l, err := net.ListenTCP("tcp", laddr)
if err != nil {
log.Fatalf("listen %s: %s", laddr, err)
}
sock, err := l.File()
if err != nil {
log.Fatalf("fd: %s", err)
}
proc, _, _, err := privsep.CreateChild(*flagUsername, os.Args[0], nil, []*os.File{sock})
if err != nil {
log.Fatalf("CreateChild failed: %s", err)
}
sock.Close()
// tidy up so child doesn't run forever
defer proc.Kill()
parent(laddr)
}
func TestCloneNEWUSERAndRemapNoRootSetgroupsEnableSetgroups(t *testing.T) {
if os.Getuid() == 0 {
t.Skip("skipping unprivileged user only test")
}
cmd := whoamiCmd(t, os.Getuid(), os.Getgid(), true)
err := cmd.Run()
if err == nil {
t.Skip("probably old kernel without security fix")
}
if !os.IsPermission(err) {
t.Fatalf("Unprivileged gid_map rewriting with GidMappingsEnableSetgroups must fail")
}
}
// Test LS_COLORS with an orphan link
func Test_LS_COLORS_orphan_link(t *testing.T) {
setup_test_dir("LS_COLORS_orphan_link")
time_now := time.Now()
_mkfile2("a", 0600, os.Getuid(), os.Getgid(), 8, time_now)
_mklink("a", "b")
_rm("a")
os.Setenv("LS_COLORS", default_LS_COLORS)
var output_buffer bytes.Buffer
args := []string{"-l"}
ls_err := ls(&output_buffer, args, tw)
output := clean_output_buffer(output_buffer)
// remove the permissions string from the output
output_noperms := strings.Join(strings.Split(output, " ")[1:], " ")
var owner string
owner_lookup, err := user.LookupId(fmt.Sprintf("%d", os.Getuid()))
if err != nil {
owner = user_map[int(os.Getuid())]
} else {
owner = owner_lookup.Username
}
group := group_map[os.Getgid()]
// link info
link_info, err := os.Lstat("b")
if err != nil {
t.Fatalf("error checking the symlink")
}
expected := fmt.Sprintf("1 %s %s %d %s %02d %02d:%02d %sb%s -> %sa%s",
owner,
group,
link_info.Size(),
time_now.Month().String()[0:3],
time_now.Day(),
time_now.Hour(),
time_now.Minute(),
"\x1b[40;31;01m",
"\x1b[0m",
"\x1b[01;05;37;41m",
"\x1b[0m")
check_output(t, output_noperms, expected)
check_error_nil(t, ls_err)
}
func main() {
// 获取系统名字
fmt.Println(os.Hostname())
// 获取系统内存
fmt.Println(os.Getpagesize())
// 获取系统环境变量
for index, env := range os.Environ() {
fmt.Println(index, " : ", env)
}
// 获取指定key的环境变量,环境变量不区分大小写
fmt.Println("当前系统目录为:", os.Getenv("windir"))
// 设置环境变量
fmt.Println("cody的环境变量为:", os.Getenv("cody"))
os.Setenv("Cody", "guo")
fmt.Println("cody的环境变量为:", os.Getenv("cody"))
// 删除所有环境变量
os.Clearenv()
fmt.Println(os.Environ())
// 如果存在os.Exit()就不会执行defer
// defer fmt.Println("我在退出吗?")
// os.Exit(0)
fmt.Println("程序已退出,不打印了...")
fmt.Println(os.Getuid(), os.Getgid())
fmt.Println(os.Getgroups())
fmt.Println(os.Getpid(), os.Getppid())
fmt.Println(os.TempDir())
}
func TestRawConnUnicastSocketOptions(t *testing.T) {
switch runtime.GOOS {
case "plan9":
t.Skipf("not supported on %q", runtime.GOOS)
}
if os.Getuid() != 0 {
t.Skip("must be root")
}
ifi := loopbackInterface()
if ifi == nil {
t.Skipf("not available on %q", runtime.GOOS)
}
c, err := net.ListenPacket("ip4:icmp", "127.0.0.1")
if err != nil {
t.Fatalf("net.ListenPacket failed: %v", err)
}
defer c.Close()
r, err := ipv4.NewRawConn(c)
if err != nil {
t.Fatalf("ipv4.NewRawConn failed: %v", err)
}
testUnicastSocketOptions(t, r)
}
// populateAttr should only be called once n.ss is known to be set and
// non-nil
func (n *node) populateAttr() error {
ss := n.ss
n.attr.Mode = ss.FileMode()
if n.fs.IgnoreOwners {
n.attr.Uid = uint32(os.Getuid())
n.attr.Gid = uint32(os.Getgid())
executeBit := n.attr.Mode & 0100
n.attr.Mode = (n.attr.Mode ^ n.attr.Mode.Perm()) & 0400 & executeBit
} else {
n.attr.Uid = uint32(ss.MapUid())
n.attr.Gid = uint32(ss.MapGid())
}
// TODO: inode?
n.attr.Mtime = ss.ModTime()
switch ss.Type {
case "file":
n.attr.Size = ss.SumPartsSize()
n.attr.Blocks = 0 // TODO: set?
case "directory":
// Nothing special? Just prevent default case.
case "symlink":
// Nothing special? Just prevent default case.
default:
log.Printf("unknown attr ss.Type %q in populateAttr", ss.Type)
}
return nil
}
func TestSetICMPFilter(t *testing.T) {
switch runtime.GOOS {
case "plan9", "windows":
t.Skipf("not supported on %q", runtime.GOOS)
}
if !supportsIPv6 {
t.Skip("ipv6 is not supported")
}
if os.Getuid() != 0 {
t.Skip("must be root")
}
c, err := net.ListenPacket("ip6:ipv6-icmp", "::1")
if err != nil {
t.Fatalf("net.ListenPacket failed: %v", err)
}
defer c.Close()
p := ipv6.NewPacketConn(c)
var f ipv6.ICMPFilter
f.SetAll(true)
f.Set(ipv6.ICMPTypeEchoRequest, false)
f.Set(ipv6.ICMPTypeEchoReply, false)
if err := p.SetICMPFilter(&f); err != nil {
t.Fatalf("ipv6.PacketConn.SetICMPFilter failed: %v", err)
}
kf, err := p.ICMPFilter()
if err != nil {
t.Fatalf("ipv6.PacketConn.ICMPFilter failed: %v", err)
}
if !reflect.DeepEqual(kf, &f) {
t.Fatalf("got unexpected filter %#v; expected %#v", kf, f)
}
}
// TestMulticastListener tests both single and double listen to a test
// listener with same address family, same group address and same port.
func TestMulticastListener(t *testing.T) {
switch runtime.GOOS {
case "netbsd", "openbsd", "plan9", "windows":
t.Logf("skipping test on %q", runtime.GOOS)
return
case "linux":
if runtime.GOARCH == "arm" || runtime.GOARCH == "alpha" {
t.Logf("skipping test on %q/%q", runtime.GOOS, runtime.GOARCH)
return
}
}
for _, tt := range multicastListenerTests {
if tt.ipv6 && (!*testIPv6 || !supportsIPv6 || os.Getuid() != 0) {
continue
}
ifi, err := availMulticastInterface(t, tt.flags)
if err != nil {
continue
}
c1, err := ListenMulticastUDP(tt.net, ifi, tt.gaddr)
if err != nil {
t.Fatalf("First ListenMulticastUDP failed: %v", err)
}
checkMulticastListener(t, err, c1, tt.gaddr)
c2, err := ListenMulticastUDP(tt.net, ifi, tt.gaddr)
if err != nil {
t.Fatalf("Second ListenMulticastUDP failed: %v", err)
}
checkMulticastListener(t, err, c2, tt.gaddr)
c2.Close()
c1.Close()
}
}
func (c *Conn) initConnection() error {
var err error
c.sysconn, err = dbus.SystemBusPrivate()
if err != nil {
return err
}
// Only use EXTERNAL method, and hardcode the uid (not username)
// to avoid a username lookup (which requires a dynamically linked
// libc)
methods := []dbus.Auth{dbus.AuthExternal(strconv.Itoa(os.Getuid()))}
err = c.sysconn.Auth(methods)
if err != nil {
c.sysconn.Close()
return err
}
err = c.sysconn.Hello()
if err != nil {
c.sysconn.Close()
return err
}
c.sysobj = c.sysconn.Object("org.freedesktop.systemd1", dbus.ObjectPath("/org/freedesktop/systemd1"))
// Setup the listeners on jobs so that we can get completions
c.sysconn.BusObject().Call("org.freedesktop.DBus.AddMatch", 0,
"type='signal', interface='org.freedesktop.systemd1.Manager', member='JobRemoved'")
c.initSubscription()
c.initDispatch()
return nil
}
func TestFileDesc_Flock(t *testing.T) {
pth := path.Join(os.TempDir(), fmt.Sprintf("goleveldbtestfd-%d", os.Getuid()))
_, err := os.Stat(pth)
if err == nil {
err = os.RemoveAll(pth)
if err != nil {
t.Fatal("RemoveAll: got error: ", err)
}
}
p1, err := OpenFile(pth)
if err != nil {
t.Fatal("OpenFile(1): got error: ", err)
}
defer os.RemoveAll(pth)
p2, err := OpenFile(pth)
if err != nil {
t.Log("OpenFile(2): got error: ", err)
} else {
p2.Close()
p1.Close()
t.Fatal("OpenFile(2): expect error")
}
p1.Close()
p3, err := OpenFile(pth)
if err != nil {
t.Fatal("OpenFile(3): got error: ", err)
}
p3.Close()
}
func switchnsExec(args []string) {
var err error
client, err := docker.GetConnection("unix:///var/run/docker.sock")
if err != nil {
fmt.Printf("Unable to connect to server\n")
os.Exit(3)
}
uid := os.Getuid()
if uid == 0 {
runCommandInContainer(client, containerName, args, envs)
} else {
var u *user.User
var containerId containers.Identifier
if u, err = user.LookupId(strconv.Itoa(uid)); err != nil {
fmt.Printf("Couldn't lookup uid %s\n", uid)
os.Exit(2)
}
if containerId, err = containers.NewIdentifierFromUser(u); err != nil {
fmt.Printf("Couldn't get identifier from user: %v\n", u)
os.Exit(2)
}
runCommandInContainer(client, containerId.ContainerFor(), []string{"/bin/sh", "-l"}, []string{})
}
}
func GetInput() {
flag.Parse()
// Using to append all fatal messages.
fatalMessages := make([]string, 0)
if os.Getuid() != 0 {
fatalMessages = append(fatalMessages, "Install script must be run with root privileges.")
}
if *UserName == "" {
fatalMessages = append(fatalMessages, "Please provide a username to -u.")
}
if *Password == "" {
fatalMessages = append(fatalMessages, "Please provide a password to -pw.")
}
if *ServerHostName == "" && *ServerIpAddress == "" {
fatalMessages = append(fatalMessages, "Please provide a server hostname to -s or a server ip address to -i.")
}
if len(fatalMessages) > 0 {
utils.Errors(fatalMessages...)
}
}
// CollectGarbage deletes any no-longer-used sockets in the UID-specific sub-
// directory of /tmp.
func CollectGarbage() {
dirName, _ := names(os.Getuid(), os.Getpid())
dir, err := os.Open(dirName)
if err != nil {
return
}
defer dir.Close()
fileNames, err := dir.Readdirnames(-1)
if err != nil {
return
}
for _, fileName := range fileNames {
if len(fileName) < 3 || fileName[:3] != "pid" {
continue
}
pid, ok := atoi(fileName[3:])
if !ok {
continue
}
// See if there is a process with the given PID. The os.FindProcess function
// looks relevant, but on Unix that always succeeds even if there is no such
// process. Instead, we send signal 0 and look for ESRCH.
if syscall.Kill(pid, 0) != syscall.ESRCH {
continue
}
os.Remove(dirName + "/" + fileName)
}
}
func TestMknod(t *testing.T) {
t.Parallel()
if os.Getuid() != 0 {
t.Skip("skipping unless root")
}
f := &mknod1{}
mnt, err := fstestutil.MountedT(t, fstestutil.SimpleFS{f})
if err != nil {
t.Fatal(err)
}
defer mnt.Close()
defer syscall.Umask(syscall.Umask(0))
err = syscall.Mknod(mnt.Dir+"/node", syscall.S_IFIFO|0666, 123)
if err != nil {
t.Fatalf("Mknod: %v", err)
}
want := fuse.MknodRequest{
Name: "node",
Mode: os.FileMode(os.ModeNamedPipe | 0666),
Rdev: uint32(123),
}
if runtime.GOOS == "linux" {
// Linux fuse doesn't echo back the rdev if the node
// isn't a device (we're using a FIFO here, as that
// bit is portable.)
want.Rdev = 0
}
if g, e := f.RecordedMknod(), want; g != e {
t.Fatalf("mknod saw %+v, want %+v", g, e)
}
}
func NewStorage() *Storage {
var stor storage.Storage
var closeFn func() error
if storageUseFS {
for {
storageMu.Lock()
num := storageNum
storageNum++
storageMu.Unlock()
path := filepath.Join(os.TempDir(), fmt.Sprintf("goleveldb-test%d0%d0%d", os.Getuid(), os.Getpid(), num))
if _, err := os.Stat(path); os.IsNotExist(err) {
stor, err = storage.OpenFile(path)
ExpectWithOffset(1, err).NotTo(HaveOccurred(), "creating storage at %s", path)
closeFn = func() error {
if storageKeepFS {
return nil
}
return os.RemoveAll(path)
}
break
}
}
} else {
stor = storage.NewMemStorage()
}
s := &Storage{
Storage: stor,
closeFn: closeFn,
opens: make(map[uint64]bool),
}
s.stallCond.L = &s.mu
return s
}
func newTestTar(entries []*testTarEntry, dir string) (string, error) {
t, err := ioutil.TempFile(dir, "tar")
if err != nil {
return "", err
}
defer t.Close()
tw := tar.NewWriter(t)
for _, entry := range entries {
// Add default mode
if entry.header.Mode == 0 {
if entry.header.Typeflag == tar.TypeDir {
entry.header.Mode = 0755
} else {
entry.header.Mode = 0644
}
}
// Add calling user uid and gid or tests will fail
entry.header.Uid = os.Getuid()
entry.header.Gid = os.Getgid()
if err := tw.WriteHeader(entry.header); err != nil {
return "", err
}
if _, err := io.WriteString(tw, entry.contents); err != nil {
return "", err
}
}
if err := tw.Close(); err != nil {
return "", err
}
return t.Name(), nil
}
func switchnsGit() {
var u *user.User
var err error
var repoId git.RepoIdentifier
uid := os.Getuid()
originalCommand := os.Getenv("SSH_ORIGINAL_COMMAND")
if u, err = user.LookupId(strconv.Itoa(uid)); err != nil {
fmt.Printf("Couldn't find user with uid %n\n", uid)
os.Exit(2)
}
if uid != 0 {
if !isValidGitCommand(originalCommand, !gitRw) {
fmt.Printf("Invalid git command: %s\n", originalCommand)
os.Exit(2)
}
if repoId, err = git.NewIdentifierFromUser(u); err != nil {
fmt.Printf("Couldn't create identifier for user %v\n", u)
os.Exit(2)
}
env := []string{fmt.Sprintf("HOME=%s", repoId.RepositoryPathFor())}
client, err := docker.GetConnection("unix:///var/run/docker.sock")
if err != nil {
fmt.Printf("Unable to connect to server\n")
os.Exit(3)
}
runCommandInContainer(client, "geard-githost", []string{"/usr/bin/git-shell", "-c", originalCommand}, env)
} else {
fmt.Println("Cannot switch into any git repo as root user")
os.Exit(2)
}
}
func (c *Conn) initConnection() error {
var err error
c.conn, err = dbus.SystemBusPrivate()
if err != nil {
return err
}
// Only use EXTERNAL method, and hardcode the uid (not username)
// to avoid a username lookup (which requires a dynamically linked
// libc)
methods := []dbus.Auth{dbus.AuthExternal(strconv.Itoa(os.Getuid()))}
err = c.conn.Auth(methods)
if err != nil {
c.conn.Close()
return err
}
err = c.conn.Hello()
if err != nil {
c.conn.Close()
return err
}
c.object = c.conn.Object("org.freedesktop.login1", dbus.ObjectPath(dbusPath))
return nil
}
func (n *mutFile) Attr() fuse.Attr {
// TODO: don't grab n.mu three+ times in here.
var mode os.FileMode = 0600 // writable
n.mu.Lock()
size := n.size
var blocks uint64
if size > 0 {
blocks = uint64(size)/512 + 1
}
inode := n.permanode.Sum64()
if n.symLink {
mode |= os.ModeSymlink
}
n.mu.Unlock()
return fuse.Attr{
Inode: inode,
Mode: mode,
Uid: uint32(os.Getuid()),
Gid: uint32(os.Getgid()),
Size: uint64(size),
Blocks: blocks,
Mtime: n.modTime(),
Atime: n.accessTime(),
Ctime: serverStart,
Crtime: serverStart,
}
}
func TestMonitorAndParseRIB(t *testing.T) {
if testing.Short() || os.Getuid() != 0 {
t.Skip("must be root")
}
// We suppose that using an IPv4 link-local address and the
// dot1Q ID for Token Ring and FDDI doesn't harm anyone.
pv := &propVirtual{addr: "169.254.0.1", mask: "255.255.255.0"}
if err := pv.configure(1002); err != nil {
t.Skip(err)
}
if err := pv.setup(); err != nil {
t.Skip(err)
}
pv.teardown()
s, err := syscall.Socket(syscall.AF_ROUTE, syscall.SOCK_RAW, syscall.AF_UNSPEC)
if err != nil {
t.Fatal(err)
}
defer syscall.Close(s)
go func() {
b := make([]byte, os.Getpagesize())
for {
n, err := syscall.Read(s, b)
if err != nil {
return
}
ms, err := ParseRIB(0, b[:n])
if err != nil {
t.Error(err)
return
}
ss, err := msgs(ms).validate()
if err != nil {
t.Error(err)
return
}
for _, s := range ss {
t.Log(s)
}
}
}()
for _, vid := range []int{1002, 1003, 1004, 1005} {
pv := &propVirtual{addr: "169.254.0.1", mask: "255.255.255.0"}
if err := pv.configure(vid); err != nil {
t.Fatal(err)
}
if err := pv.setup(); err != nil {
t.Fatal(err)
}
time.Sleep(200 * time.Millisecond)
if err := pv.teardown(); err != nil {
t.Fatal(err)
}
time.Sleep(200 * time.Millisecond)
}
}
func (n *atDir) Attr() fuse.Attr {
return fuse.Attr{
Mode: os.ModeDir | 0500,
Uid: uint32(os.Getuid()),
Gid: uint32(os.Getgid()),
}
}
func (n *roFile) Attr(ctx context.Context, a *fuse.Attr) error {
// TODO: don't grab n.mu three+ times in here.
var mode os.FileMode = 0400 // read-only
n.mu.Lock()
size := n.size
var blocks uint64
if size > 0 {
blocks = uint64(size)/512 + 1
}
inode := n.permanode.Sum64()
if n.symLink {
mode |= os.ModeSymlink
}
n.mu.Unlock()
*a = fuse.Attr{
Inode: inode,
Mode: mode,
Uid: uint32(os.Getuid()),
Gid: uint32(os.Getgid()),
Size: uint64(size),
Blocks: blocks,
Mtime: n.modTime(),
Atime: n.accessTime(),
Ctime: serverStart,
Crtime: serverStart,
}
return nil
}
func skipTest(t *testing.T) bool {
if runtime.GOOS == "linux" && os.Getuid() != 0 {
fmt.Println("SKIP: test must be run as root on linux")
return true
}
return false
}
func skipRawSocketTests() bool {
if os.Getuid() != 0 {
return true
}
return false
}