code review 12349044: os, syscall: implement Getwd on darwin using getattrlist

src/pkg/syscall/syscall_darwin.go

 // Copyright 2009,2010 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.
 
 // Darwin system calls.
 // 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 that sometimes we use a lowercase //sys name and wrap
 // it in our own nicer implementation, either here or in
 // syscall_bsd.go or syscall_unix.go.
 
 package syscall
 
-import "unsafe"
+import (
+        errorspkg "errors"
+        "unsafe"
+)
 
 type SockaddrDatalink struct {
         Len    uint8
         Family uint8
         Index  uint16
         Type   uint8
         Nlen   uint8
         Alen   uint8
         Slen   uint8
         Data   [12]int8
@@ skipping 53 matching lines @@
                 count++
                 names = append(names, name)
         }
         return origlen - len(buf), count, names
 }
 
 //sys   ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
 func PtraceAttach(pid int) (err error) { return ptrace(PT_ATTACH, pid, 0, 0) }
 func PtraceDetach(pid int) (err error) { return ptrace(PT_DETACH, pid, 0, 0) }
 
+const (
+        attrBitMapCount = 5
+        AttrCmnFullpath = 0x08000000
+)
+
+type AttrList struct {
+        bitmapCount uint16
+        _           uint16
+        CommonAttr  uint32
+        VolAttr     uint32
+        DirAttr     uint32
+        FileAttr    uint32
+        Forkattr    uint32
+}
+
+func GetAttrList(path string, attrList AttrList, attrBuf []byte, options uint) (attrs [][]byte, err error) {
+        if len(attrBuf) < 4 {
+                return nil, errorspkg.New("attrBuf too small")
+        }
+        attrList.bitmapCount = attrBitMapCount
+
+        var _p0 *byte
+        _p0, err = BytePtrFromString(path)
+        if err != nil {
+                return nil, err
+        }
+
+        _, _, e1 := Syscall6(
+                SYS_GETATTRLIST,
+                uintptr(unsafe.Pointer(_p0)),
+                uintptr(unsafe.Pointer(&attrList)),
+                uintptr(unsafe.Pointer(&attrBuf[0])),
+                uintptr(len(attrBuf)),
+                uintptr(options),
+                0,
+        )
+        if e1 != 0 {
+                return nil, e1
+        }
+        size := *(*uint32)(unsafe.Pointer(&attrBuf[0]))
+
+        // dat is the section of attrBuf that contains valid data,
+        // without the 4 byte length header. All attribute offsets
+        // are relative to dat.
+        dat := attrBuf
+        if int(size) < len(attrBuf) {
+                dat = dat[:size]
+        }
+        dat = dat[4:] // remove length prefix
+
+        for i := uint32(0); int(i) < len(dat); {
+                header := dat[i:]
+                if len(header) < 8 {
+                        return attrs, errorspkg.New("truncated attribute header")
+                }
+                datOff := *(*int32)(unsafe.Pointer(&header[0]))
+                attrLen := *(*uint32)(unsafe.Pointer(&header[4]))
+                if datOff < 0 || uint32(datOff)+attrLen > uint32(len(dat)) {
+                        return attrs, errorspkg.New("truncated results; attrBuf too small")
+                }
+                end := uint32(datOff) + attrLen
+                attrs = append(attrs, dat[datOff:end])
+                i = end
+                if r := i % 4; r != 0 {
+                        i += (4 - r)
+                }
+        }
+        return
+}
+
 //sysnb pipe() (r int, w int, err error)
 
 func Pipe(p []int) (err error) {
         if len(p) != 2 {
                 return EINVAL
         }
         p[0], p[1], err = pipe()
         return
 }
 
@@ skipping 290 matching lines @@
 // Poll_nocancel
 // Msgsnd_nocancel
 // Msgrcv_nocancel
 // Sem_wait_nocancel
 // Aio_suspend_nocancel
 // __sigwait_nocancel
 // __semwait_signal_nocancel
 // __mac_mount
 // __mac_get_mount
 // __mac_getfsstat