Home | History | Annotate | Download | only in os
      1 // Copyright 2011 The Go Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style
      3 // license that can be found in the LICENSE file.
      4 
      5 package os
      6 
      7 import (
      8 	"syscall"
      9 	"time"
     10 )
     11 
     12 const _BIT16SZ = 2
     13 
     14 func fileInfoFromStat(d *syscall.Dir) FileInfo {
     15 	fs := &fileStat{
     16 		name:    d.Name,
     17 		size:    d.Length,
     18 		modTime: time.Unix(int64(d.Mtime), 0),
     19 		sys:     d,
     20 	}
     21 	fs.mode = FileMode(d.Mode & 0777)
     22 	if d.Mode&syscall.DMDIR != 0 {
     23 		fs.mode |= ModeDir
     24 	}
     25 	if d.Mode&syscall.DMAPPEND != 0 {
     26 		fs.mode |= ModeAppend
     27 	}
     28 	if d.Mode&syscall.DMEXCL != 0 {
     29 		fs.mode |= ModeExclusive
     30 	}
     31 	if d.Mode&syscall.DMTMP != 0 {
     32 		fs.mode |= ModeTemporary
     33 	}
     34 	// Consider all files not served by #M as device files.
     35 	if d.Type != 'M' {
     36 		fs.mode |= ModeDevice
     37 	}
     38 	return fs
     39 }
     40 
     41 // arg is an open *File or a path string.
     42 func dirstat(arg interface{}) (*syscall.Dir, error) {
     43 	var name string
     44 	var err error
     45 
     46 	size := syscall.STATFIXLEN + 16*4
     47 
     48 	for i := 0; i < 2; i++ {
     49 		buf := make([]byte, _BIT16SZ+size)
     50 
     51 		var n int
     52 		switch a := arg.(type) {
     53 		case *File:
     54 			name = a.name
     55 			n, err = syscall.Fstat(a.fd, buf)
     56 		case string:
     57 			name = a
     58 			n, err = syscall.Stat(a, buf)
     59 		default:
     60 			panic("phase error in dirstat")
     61 		}
     62 
     63 		if n < _BIT16SZ {
     64 			return nil, &PathError{"stat", name, err}
     65 		}
     66 
     67 		// Pull the real size out of the stat message.
     68 		size = int(uint16(buf[0]) | uint16(buf[1])<<8)
     69 
     70 		// If the stat message is larger than our buffer we will
     71 		// go around the loop and allocate one that is big enough.
     72 		if size <= n {
     73 			d, err := syscall.UnmarshalDir(buf[:n])
     74 			if err != nil {
     75 				return nil, &PathError{"stat", name, err}
     76 			}
     77 			return d, nil
     78 		}
     79 
     80 	}
     81 
     82 	if err == nil {
     83 		err = syscall.ErrBadStat
     84 	}
     85 
     86 	return nil, &PathError{"stat", name, err}
     87 }
     88 
     89 // statNolog implements Stat for Plan 9.
     90 func statNolog(name string) (FileInfo, error) {
     91 	d, err := dirstat(name)
     92 	if err != nil {
     93 		return nil, err
     94 	}
     95 	return fileInfoFromStat(d), nil
     96 }
     97 
     98 // lstatNolog implements Lstat for Plan 9.
     99 func lstatNolog(name string) (FileInfo, error) {
    100 	return statNolog(name)
    101 }
    102 
    103 // For testing.
    104 func atime(fi FileInfo) time.Time {
    105 	return time.Unix(int64(fi.Sys().(*syscall.Dir).Atime), 0)
    106 }
    107