dotcloud/docker

package loggerutils

import (
    "os"
    "path/filepath"
    "syscall"
    "unsafe"
)

func open(name string) (*os.File, error) {
    return openFile(name, os.O_RDONLY, 0)
}

func openFile(name string, flag int, perm os.FileMode) (*os.File, error) {
    if name == "" {
        return nil, &os.PathError{Op: "open", Path: name, Err: syscall.ENOENT}
    }
    h, err := syscallOpen(fixLongPath(name), flag|syscall.O_CLOEXEC, syscallMode(perm))
    if err != nil {
        return nil, &os.PathError{Op: "open", Path: name, Err: err}
    }
    return os.NewFile(uintptr(h), name), nil
}

// syscallOpen is copied from syscall.Open but is modified to
// always open a file with FILE_SHARE_DELETE
func syscallOpen(path string, mode int, perm uint32) (fd syscall.Handle, err error) {
    if len(path) == 0 {
        return syscall.InvalidHandle, syscall.ERROR_FILE_NOT_FOUND
    }

    pathp, err := syscall.UTF16PtrFromString(path)
    if err != nil {
        return syscall.InvalidHandle, err
    }
    var access uint32
    switch mode & (syscall.O_RDONLY | syscall.O_WRONLY | syscall.O_RDWR) {
    case syscall.O_RDONLY:
        access = syscall.GENERIC_READ
    case syscall.O_WRONLY:
        access = syscall.GENERIC_WRITE
    case syscall.O_RDWR:
        access = syscall.GENERIC_READ | syscall.GENERIC_WRITE
    }
    if mode&syscall.O_CREAT != 0 {
        access |= syscall.GENERIC_WRITE
    }
    if mode&syscall.O_APPEND != 0 {
        access &^= syscall.GENERIC_WRITE
        access |= syscall.FILE_APPEND_DATA
    }
    sharemode := uint32(syscall.FILE_SHARE_READ | syscall.FILE_SHARE_WRITE | syscall.FILE_SHARE_DELETE)
    var sa *syscall.SecurityAttributes
    if mode&syscall.O_CLOEXEC == 0 {
        sa = makeInheritSa()
    }
    var createmode uint32
    switch {
    case mode&(syscall.O_CREAT|syscall.O_EXCL) == (syscall.O_CREAT | syscall.O_EXCL):
        createmode = syscall.CREATE_NEW
    case mode&(syscall.O_CREAT|syscall.O_TRUNC) == (syscall.O_CREAT | syscall.O_TRUNC):
        createmode = syscall.CREATE_ALWAYS
    case mode&syscall.O_CREAT == syscall.O_CREAT:
        createmode = syscall.OPEN_ALWAYS
    case mode&syscall.O_TRUNC == syscall.O_TRUNC:
        createmode = syscall.TRUNCATE_EXISTING
    default:
        createmode = syscall.OPEN_EXISTING
    }
    h, e := syscall.CreateFile(pathp, access, sharemode, sa, createmode, syscall.FILE_ATTRIBUTE_NORMAL, 0)
    return h, e
}

func makeInheritSa() *syscall.SecurityAttributes {
    var sa syscall.SecurityAttributes
    sa.Length = uint32(unsafe.Sizeof(sa))
    sa.InheritHandle = 1
    return &sa
}

// fixLongPath returns the extended-length (\\?\-prefixed) form of
// path when needed, in order to avoid the default 260 character file
// path limit imposed by Windows. If path is not easily converted to
// the extended-length form (for example, if path is a relative path
// or contains .. elements), or is short enough, fixLongPath returns
// path unmodified.
//
// See https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx#maxpath
//
// Copied from os.OpenFile
func fixLongPath(path string) string {
    // Do nothing (and don't allocate) if the path is "short".
    // Empirically (at least on the Windows Server 2013 builder),
    // the kernel is arbitrarily okay with < 248 bytes. That
    // matches what the docs above say:
    // "When using an API to create a directory, the specified
    // path cannot be so long that you cannot append an 8.3 file
    // name (that is, the directory name cannot exceed MAX_PATH
    // minus 12)." Since MAX_PATH is 260, 260 - 12 = 248.
    //
    // The MSDN docs appear to say that a normal path that is 248 bytes long
    // will work; empirically the path must be less then 248 bytes long.
    if len(path) < 248 {
        // Don't fix. (This is how Go 1.7 and earlier worked,
        // not automatically generating the \\?\ form)
        return path
    }

    // The extended form begins with \\?\, as in
    // \\?\c:\windows\foo.txt or \\?\UNC\server\share\foo.txt.
    // The extended form disables evaluation of . and .. path
    // elements and disables the interpretation of / as equivalent
    // to \. The conversion here rewrites / to \ and elides
    // . elements as well as trailing or duplicate separators. For
    // simplicity it avoids the conversion entirely for relative
    // paths or paths containing .. elements. For now,
    // \\server\share paths are not converted to
    // \\?\UNC\server\share paths because the rules for doing so
    // are less well-specified.
    if len(path) >= 2 && path[:2] == `\\` {
        // Don't canonicalize UNC paths.
        return path
    }
    if !isAbs(path) {
        // Relative path
        return path
    }

    const prefix = `\\?`

    pathbuf := make([]byte, len(prefix)+len(path)+len(`\`))
    copy(pathbuf, prefix)
    n := len(path)
    r, w := 0, len(prefix)
    for r < n {
        switch {
        case os.IsPathSeparator(path[r]):
            // empty block
            r++
        case path[r] == '.' && (r+1 == n || os.IsPathSeparator(path[r+1])):
            // /./
            r++
        case r+1 < n && path[r] == '.' && path[r+1] == '.' && (r+2 == n || os.IsPathSeparator(path[r+2])):
            // /../ is currently unhandled
            return path
        default:
            pathbuf[w] = '\\'
            w++
            for ; r < n && !os.IsPathSeparator(path[r]); r++ {
                pathbuf[w] = path[r]
                w++
            }
        }
    }
    // A drive's root directory needs a trailing \
    if w == len(`\\?\c:`) {
        pathbuf[w] = '\\'
        w++
    }
    return string(pathbuf[:w])
}

// copied from os package for os.OpenFile
func syscallMode(i os.FileMode) (o uint32) {
    o |= uint32(i.Perm())
    if i&os.ModeSetuid != 0 {
        o |= syscall.S_ISUID
    }
    if i&os.ModeSetgid != 0 {
        o |= syscall.S_ISGID
    }
    if i&os.ModeSticky != 0 {
        o |= syscall.S_ISVTX
    }
    // No mapping for Go's ModeTemporary (plan9 only).
    return
}

func isAbs(path string) (b bool) {
    v := volumeName(path)
    if v == "" {
        return false
    }
    path = path[len(v):]
    if path == "" {
        return false
    }
    return os.IsPathSeparator(path[0])
}

func volumeName(path string) (v string) {
    if len(path) < 2 {
        return ""
    }
    // with drive letter
    c := path[0]
    if path[1] == ':' &&
        ('0' <= c && c <= '9' || 'a' <= c && c <= 'z' ||
            'A' <= c && c <= 'Z') {
        return path[:2]
    }
    // is it UNC
    if l := len(path); l >= 5 && os.IsPathSeparator(path[0]) && os.IsPathSeparator(path[1]) &&
        !os.IsPathSeparator(path[2]) && path[2] != '.' {
        // first, leading `\\` and next shouldn't be `\`. its server name.
        for n := 3; n < l-1; n++ {
            // second, next '\' shouldn't be repeated.
            if os.IsPathSeparator(path[n]) {
                n++
                // third, following something characters. its share name.
                if !os.IsPathSeparator(path[n]) {
                    if path[n] == '.' {
                        break
                    }
                    for ; n < l; n++ {
                        if os.IsPathSeparator(path[n]) {
                            break
                        }
                    }
                    return path[:n]
                }
                break
            }
        }
    }
    return ""
}

func unlink(name string) error {
    // Rename the file before deleting it so that the original name is freed
    // up to be reused, even while there are still open FILE_SHARE_DELETE
    // file handles. Emulate POSIX unlink() semantics, essentially.
    name, err := filepath.Abs(name)
    if err != nil {
        return err
    }
    dir, fname := filepath.Split(name)
    f, err := os.CreateTemp(dir, fname+".*.deleted")
    if err != nil {
        return err
    }
    tmpname := f.Name()
    if err := f.Close(); err != nil {
        return err
    }
    err = os.Rename(name, tmpname)
    rmErr := os.Remove(tmpname)
    if err != nil {
        return err
    }
    return rmErr
}