io/ioutil: ReadDir: no error if `dirname` is a file

[larsbutler]

Hi, I noticed that if you run ioutil.ReadDir("/some/file.txt"), it succeeds and returns an empty array of os.FileInfo and no error. I would expect an error, since the input is a file, not a dir.

See

go/src/io/ioutil/ioutil.go

Line 100 in c007ce8

func ReadDir(dirname string) ([]os.FileInfo, error) {

.

Equivalent operations in the stdlib of, for example, Python are os.listdir, and this raises an error if you pass in a file instead of a directory.

Is this a bug, or is this the intended behavior? If the latter, why?

If it's a bug I'll be happy to submit a patch.

Thanks!

[ianlancetaylor]

I think it would be reasonable to check that os.File.Readdir and os.File.Readdirnames return an error if used on a non-directory. As far as I can see that should already happens on GNU/Linux. What OS are you using?

[larsbutler]

@ianlancetaylor
I'm running OSX 10.8.5.

[bradfitz]

On Linux:

--- PASS: TestReadDirOnFile (0.00s)
        ioutil_test.go:106: Got [], readdirent: not a directory

On OS X:

--- PASS: TestReadDirOnFile (0.00s)
    ioutil_test.go:106: Got [], <nil>

[bradfitz]

syscall.Getdirentries is actually returning EINVAL on OS X, but @rsc added Yosemite work-around code to mask that error away.

With my added logging the syscall func is:

func ReadDirent(fd int, buf []byte) (n int, err error) {
        // Final argument is (basep *uintptr) and the syscall doesn't take nil.                                                                                             
        // 64 bits should be enough. (32 bits isn't even on 386). Since the                                                                                                 
        // actual system call is getdirentries64, 64 is a good guess.                                                                                                       
        // TODO(rsc): Can we use a single global basep for all calls?                                                                                                       
        var base = (*uintptr)(unsafe.Pointer(new(uint64)))
        n, err = Getdirentries(fd, buf, base)

        println("syscall.ReadDirent", n, err)
        if err != nil {
                println("syscall.ReadDirent == " + err.Error())
        }

        // On OS X 10.10 Yosemite, if you have a directory that can be returned                                                                                             
        // in a single getdirentries64 call (for example, a directory with one file),                                                                                       
        // and you read from the directory at EOF twice, you get EOF both times:                                                                                            
        //      fd = open("dir")                                                                                                                                            
        //      getdirentries64(fd) // returns data                                                                                                                         
        //      getdirentries64(fd) // returns 0 (EOF)                                                                                                                      
        //      getdirentries64(fd) // returns 0 (EOF)                                                                                                                      
        //                                                                                                                                                                  
        // But if you remove the file in the middle between the two calls, the                                                                                              
        // second call returns an error instead.                                                                                                                            
        //      fd = open("dir")                                                                                                                                            
        //      getdirentries64(fd) // returns data                                                                                                                         
        //      getdirentries64(fd) // returns 0 (EOF)                                                                                                                      
        //      remove("dir/file")                                                                                                                                          
        //      getdirentries64(fd) // returns ENOENT/EINVAL                                                                                                                
        //                                                                                                                                                                  
        // Whether you get ENOENT or EINVAL depends on exactly what was                                                                                                     
        // in the directory. It is deterministic, just data-dependent.                                                                                                      
        //                                                                                                                                                                  
        // This only happens in small directories. A directory containing more data                                                                                         
        // than fits in a 4k getdirentries64 call will return EOF correctly.                                                                                                
        // (It's not clear if the criteria is that the directory be split across multiple                                                                                   
        // getdirentries64 calls or that it be split across multiple file system blocks.)                                                                                   
        //                                                                                                                                                                  
        // We could change package os to avoid the second read at EOF,                                                                                                      
        // and maybe we should, but that's a bit involved.                                                                                                                  
        // For now, treat the EINVAL/ENOENT as EOF.                                                                                                                         
        if runtime.GOOS == "darwin" && (err == EINVAL || err == ENOENT) {
                err = nil
        }

        return
}

But I thought that the Yosemite issue was fixed?

[bradfitz]

The commit that added the Yosemite workaround was a83bbc9

[bradfitz]

I've sent https://go-review.googlesource.com/4164