syscall: correctly pad with NUL in FreeBSD convertFromDirents11

We weren't writing a terminating NUL after dstDirent.Namlen bytes of dstDirent.Name.
And we weren't filling the possible additional bytes until dstDirent.Reclen.

Fixes #28131

Change-Id: Id691c25225795c0dbb0d7004bfca7bb7fc706de9
Reviewed-on: https://go-review.googlesource.com/c/141297
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

diff --git a/src/syscall/dirent_bsd_test.go b/src/syscall/dirent_bsd_test.go
new file mode 100644 (file)
index 0000000..e5b8357
--- /dev/null
+++ b/src/syscall/dirent_bsd_test.go
@@ -0,0 +1,76 @@
+// Copyright 2018 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.
+
+// +build darwin dragonfly freebsd netbsd openbsd
+
+package syscall_test
+
+import (
+       "bytes"
+       "io/ioutil"
+       "os"
+       "path/filepath"
+       "sort"
+       "strconv"
+       "strings"
+       "syscall"
+       "testing"
+)
+
+func TestDirent(t *testing.T) {
+       const (
+               direntBufSize   = 2048
+               filenameMinSize = 11
+       )
+
+       d, err := ioutil.TempDir("", "dirent-test")
+       if err != nil {
+               t.Fatalf("tempdir: %v", err)
+       }
+       defer os.RemoveAll(d)
+       t.Logf("tmpdir: %s", d)
+
+       for i, c := range []byte("0123456789") {
+               name := string(bytes.Repeat([]byte{c}, filenameMinSize+i))
+               err = ioutil.WriteFile(filepath.Join(d, name), nil, 0644)
+               if err != nil {
+                       t.Fatalf("writefile: %v", err)
+               }
+       }
+
+       buf := bytes.Repeat([]byte("DEADBEAF"), direntBufSize/8)
+       fd, err := syscall.Open(d, syscall.O_RDONLY, 0)
+       defer syscall.Close(fd)
+       if err != nil {
+               t.Fatalf("syscall.open: %v", err)
+       }
+       n, err := syscall.ReadDirent(fd, buf)
+       if err != nil {
+               t.Fatalf("syscall.readdir: %v", err)
+       }
+       buf = buf[:n]
+
+       names := make([]string, 0, 10)
+       for len(buf) > 0 {
+               var bc int
+               bc, _, names = syscall.ParseDirent(buf, -1, names)
+               buf = buf[bc:]
+       }
+
+       sort.Strings(names)
+       t.Logf("names: %q", names)
+
+       if len(names) != 10 {
+               t.Errorf("got %d names; expected 10", len(names))
+       }
+       for i, name := range names {
+               ord, err := strconv.Atoi(name[:1])
+               if err != nil {
+                       t.Fatalf("names[%d] is non-integer %q: %v", i, names[i], err)
+               }
+               if expected := string(strings.Repeat(name[:1], filenameMinSize+ord)); name != expected {
+                       t.Errorf("names[%d] is %q (len %d); expected %q (len %d)", i, name, len(name), expected, len(expected))
+               }
+       }
+}

diff --git a/src/syscall/syscall_freebsd.go b/src/syscall/syscall_freebsd.go
index e1181200480d9b93a299153d5e32a9a43dca5045..9ae024131dbe60d9156a3efc71a9d1d756753556 100644 (file)
--- a/src/syscall/syscall_freebsd.go
+++ b/src/syscall/syscall_freebsd.go
@@ -344,18 +344,17 @@ func (s *Statfs_t) convertFrom(old *statfs_freebsd11_t) {
        copy(s.Mntonname[:], old.Mntonname[:n])
 }
 
-func convertFromDirents11(oldBuf []byte, buf []byte) int {
-       src := unsafe.Pointer(&oldBuf[0])
-       esrc := unsafe.Pointer(uintptr(src) + uintptr(len(oldBuf)))
-       dst := unsafe.Pointer(&buf[0])
-       edst := unsafe.Pointer(uintptr(dst) + uintptr(len(buf)))
-
-       for uintptr(src) < uintptr(esrc) && uintptr(dst) < uintptr(edst) {
-               srcDirent := (*dirent_freebsd11)(src)
-               dstDirent := (*Dirent)(dst)
-
-               reclen := roundup(int(unsafe.Offsetof(dstDirent.Name)+uintptr(srcDirent.Namlen)+1), 8)
-               if uintptr(dst)+uintptr(reclen) >= uintptr(edst) {
+func convertFromDirents11(old []byte, buf []byte) int {
+       oldFixedSize := int(unsafe.Offsetof((*dirent_freebsd11)(nil).Name))
+       fixedSize := int(unsafe.Offsetof((*Dirent)(nil).Name))
+       srcPos := 0
+       dstPos := 0
+       for dstPos+fixedSize < len(buf) && srcPos+oldFixedSize < len(old) {
+               srcDirent := (*dirent_freebsd11)(unsafe.Pointer(&old[srcPos]))
+               dstDirent := (*Dirent)(unsafe.Pointer(&buf[dstPos]))
+
+               reclen := roundup(fixedSize+int(srcDirent.Namlen)+1, 8)
+               if dstPos+reclen >= len(buf) {
                        break
                }
 
@@ -367,18 +366,17 @@ func convertFromDirents11(oldBuf []byte, buf []byte) int {
                dstDirent.Namlen = uint16(srcDirent.Namlen)
                dstDirent.Pad1 = 0
 
-               sl := srcDirent.Name[:]
-               n := clen(*(*[]byte)(unsafe.Pointer(&sl)))
-               copy(dstDirent.Name[:], srcDirent.Name[:n])
-               for i := n; i < int(dstDirent.Namlen); i++ {
-                       dstDirent.Name[i] = 0
+               copy(dstDirent.Name[:], srcDirent.Name[:srcDirent.Namlen])
+               padding := buf[dstPos+fixedSize+int(dstDirent.Namlen) : dstPos+reclen]
+               for i := range padding {
+                       padding[i] = 0
                }
 
-               src = unsafe.Pointer(uintptr(src) + uintptr(srcDirent.Reclen))
-               dst = unsafe.Pointer(uintptr(dst) + uintptr(reclen))
+               dstPos += int(dstDirent.Reclen)
+               srcPos += int(srcDirent.Reclen)
        }
 
-       return int(uintptr(dst) - uintptr(unsafe.Pointer((&buf[0]))))
+       return dstPos
 }
 
 /*