internal/fastwalk/fastwalk_darwin.go

// Copyright 2022 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 darwin && cgo
// +build darwin,cgo

package fastwalk

/*
#include <dirent.h>

// fastwalk_readdir_r wraps readdir_r so that we don't have to pass a dirent**
// result pointer which triggers CGO's "Go pointer to Go pointer" check unless
// we allocat the result dirent* with malloc.
//
// fastwalk_readdir_r returns 0 on success, -1 upon reaching the end of the
// directory, or a positive error number to indicate failure.
static int fastwalk_readdir_r(DIR *fd, struct dirent *entry) {
	struct dirent *result;
	int ret = readdir_r(fd, entry, &result);
	if (ret == 0 && result == NULL) {
		ret = -1; // EOF
	}
	return ret;
}
*/
import "C"

import (
	"os"
	"syscall"
	"unsafe"
)

func readDir(dirName string, fn func(dirName, entName string, typ os.FileMode) error) error {
	fd, err := openDir(dirName)
	if err != nil {
		return &os.PathError{Op: "opendir", Path: dirName, Err: err}
	}
	defer C.closedir(fd)

	skipFiles := false
	var dirent syscall.Dirent
	for {
		ret := int(C.fastwalk_readdir_r(fd, (*C.struct_dirent)(unsafe.Pointer(&dirent))))
		if ret != 0 {
			if ret == -1 {
				break // EOF
			}
			if ret == int(syscall.EINTR) {
				continue
			}
			return &os.PathError{Op: "readdir", Path: dirName, Err: syscall.Errno(ret)}
		}
		if dirent.Ino == 0 {
			continue
		}
		typ := dtToType(dirent.Type)
		if skipFiles && typ.IsRegular() {
			continue
		}
		name := (*[len(syscall.Dirent{}.Name)]byte)(unsafe.Pointer(&dirent.Name))[:]
		name = name[:dirent.Namlen]
		for i, c := range name {
			if c == 0 {
				name = name[:i]
				break
			}
		}
		// Check for useless names before allocating a string.
		if string(name) == "." || string(name) == ".." {
			continue
		}
		if err := fn(dirName, string(name), typ); err != nil {
			if err != ErrSkipFiles {
				return err
			}
			skipFiles = true
		}
	}

	return nil
}

func dtToType(typ uint8) os.FileMode {
	switch typ {
	case syscall.DT_BLK:
		return os.ModeDevice
	case syscall.DT_CHR:
		return os.ModeDevice | os.ModeCharDevice
	case syscall.DT_DIR:
		return os.ModeDir
	case syscall.DT_FIFO:
		return os.ModeNamedPipe
	case syscall.DT_LNK:
		return os.ModeSymlink
	case syscall.DT_REG:
		return 0
	case syscall.DT_SOCK:
		return os.ModeSocket
	}
	return ^os.FileMode(0)
}

// openDir wraps opendir(3) and handles any EINTR errors. The returned *DIR
// needs to be closed with closedir(3).
func openDir(path string) (*C.DIR, error) {
	name, err := syscall.BytePtrFromString(path)
	if err != nil {
		return nil, err
	}
	for {
		fd, err := C.opendir((*C.char)(unsafe.Pointer(name)))
		if err != syscall.EINTR {
			return fd, err
		}
	}
}