win32stat.c File Reference

#include "c.h"
#include "port/win32ntdll.h"
#include <windows.h>

Include dependency graph for win32stat.c:

Go to the source code of this file.

Functions
static __time64_t	filetime_to_time (const FILETIME *ft)
static unsigned short	fileattr_to_unixmode (int attr)
static int	fileinfo_to_stat (HANDLE hFile, struct stat *buf)
int	_pglstat64 (const char *name, struct stat *buf)
int	_pgstat64 (const char *name, struct stat *buf)
int	_pgfstat64 (int fileno, struct stat *buf)

Function Documentation

_pgfstat64()

int _pgfstat64	(	int	fileno,
		struct stat *	buf
	)

Definition at line 260 of file win32stat.c.

{
    HANDLE      hFile = (HANDLE) _get_osfhandle(fileno);
    DWORD       fileType = FILE_TYPE_UNKNOWN;
    unsigned short st_mode;
 
    if (buf == NULL)
    {
        errno = EINVAL;
        return -1;
    }
 
    fileType = pgwin32_get_file_type(hFile);
    if (errno != 0)
        return -1;
 
    switch (fileType)
    {
            /* The specified file is a disk file */
        case FILE_TYPE_DISK:
            return fileinfo_to_stat(hFile, buf);
 
            /*
             * The specified file is a socket, a named pipe, or an anonymous
             * pipe.
             */
        case FILE_TYPE_PIPE:
            st_mode = _S_IFIFO;
            break;
            /* The specified file is a character file */
        case FILE_TYPE_CHAR:
            st_mode = _S_IFCHR;
            break;
            /* Unused flag and unknown file type */
        case FILE_TYPE_REMOTE:
        case FILE_TYPE_UNKNOWN:
        default:
            errno = EINVAL;
            return -1;
    }
 
    memset(buf, 0, sizeof(*buf));
    buf->st_mode = st_mode;
    buf->st_dev = fileno;
    buf->st_rdev = fileno;
    buf->st_nlink = 1;
    return 0;
}

References buf, EINVAL, fb(), fileinfo_to_stat(), and pgwin32_get_file_type().

_pglstat64()

int _pglstat64	(	const char *	name,
		struct stat *	buf
	)

Definition at line 113 of file win32stat.c.

{
    /*
     * Our open wrapper will report STATUS_DELETE_PENDING as ENOENT.  We
     * request FILE_FLAG_BACKUP_SEMANTICS so that we can open directories too,
     * for limited purposes.  We use the private handle-based version, so we
     * don't risk running out of fds.
     */
    HANDLE      hFile;
    int         ret;
 
    hFile = pgwin32_open_handle(name, O_RDONLY, true);
    if (hFile == INVALID_HANDLE_VALUE)
    {
        if (errno == ENOENT)
        {
            /*
             * If it's a junction point pointing to a non-existent path, we'll
             * have ENOENT here (because pgwin32_open_handle does not use
             * FILE_FLAG_OPEN_REPARSE_POINT).  In that case, we'll try again
             * with readlink() below, which will distinguish true ENOENT from
             * pseudo-symlink.
             */
            memset(buf, 0, sizeof(*buf));
            ret = 0;
        }
        else
            return -1;
    }
    else
        ret = fileinfo_to_stat(hFile, buf);
 
    /*
     * Junction points appear as directories to fileinfo_to_stat(), so we'll
     * need to do a bit more work to distinguish them.
     */
    if ((ret == 0 && S_ISDIR(buf->st_mode)) || hFile == INVALID_HANDLE_VALUE)
    {
        char        next[MAXPGPATH];
        ssize_t     size;
 
        /*
         * POSIX says we need to put the length of the target path into
         * st_size.  Use readlink() to get it, or learn that this is not a
         * junction point.
         */
        size = readlink(name, next, sizeof(next));
        if (size < 0)
        {
            if (errno == EACCES &&
                pg_RtlGetLastNtStatus() == STATUS_DELETE_PENDING)
            {
                /* Unlinked underneath us. */
                errno = ENOENT;
                ret = -1;
            }
            else if (errno == EINVAL)
            {
                /* It's not a junction point, nothing to do. */
            }
            else
            {
                /* Some other failure. */
                ret = -1;
            }
        }
        else if (size >= sizeof(next))
        {
            errno = ENAMETOOLONG;
            ret = -1;
        }
        else
        {
            /* It's a junction point, so report it as a symlink. */
            buf->st_mode &= ~S_IFDIR;
            buf->st_mode |= S_IFLNK;
            buf->st_size = size;
            ret = 0;
        }
    }
 
    if (hFile != INVALID_HANDLE_VALUE)
        CloseHandle(hFile);
    return ret;
}

References buf, EINVAL, ENAMETOOLONG, fb(), fileinfo_to_stat(), MAXPGPATH, name, next, pg_RtlGetLastNtStatus, readlink, S_IFLNK, and S_ISDIR.

Referenced by _pgstat64().

_pgstat64()

int _pgstat64	(	const char *	name,
		struct stat *	buf
	)

Definition at line 203 of file win32stat.c.

{
    int         loops = 0;
    int         ret;
    char        curr[MAXPGPATH];
 
    ret = _pglstat64(name, buf);
 
    strlcpy(curr, name, MAXPGPATH);
 
    /* Do we need to follow a symlink (junction point)? */
    while (ret == 0 && S_ISLNK(buf->st_mode))
    {
        char        next[MAXPGPATH];
        ssize_t     size;
 
        if (++loops > 8)
        {
            errno = ELOOP;
            return -1;
        }
 
        /*
         * _pglstat64() already called readlink() once to be able to fill in
         * st_size, and now we need to do it again to get the path to follow.
         * That could be optimized, but stat() on symlinks is probably rare
         * and this way is simple.
         */
        size = readlink(curr, next, sizeof(next));
        if (size < 0)
        {
            if (errno == EACCES &&
                pg_RtlGetLastNtStatus() == STATUS_DELETE_PENDING)
            {
                /* Unlinked underneath us. */
                errno = ENOENT;
            }
            return -1;
        }
        else if (size >= sizeof(next))
        {
            errno = ENAMETOOLONG;
            return -1;
        }
        next[size] = 0;
 
        ret = _pglstat64(next, buf);
        strcpy(curr, next);
    }
 
    return ret;
}

References _pglstat64(), buf, ELOOP, ENAMETOOLONG, fb(), MAXPGPATH, name, next, pg_RtlGetLastNtStatus, readlink, S_ISLNK, and strlcpy().

fileattr_to_unixmode()

static unsigned short fileattr_to_unixmode ( int  attr )

static

Definition at line 48 of file win32stat.c.

{
    unsigned short uxmode = 0;
 
    uxmode |= (unsigned short) ((attr & FILE_ATTRIBUTE_DIRECTORY) ?
                                (_S_IFDIR) : (_S_IFREG));
 
    uxmode |= (unsigned short) ((attr & FILE_ATTRIBUTE_READONLY) ?
                                (_S_IREAD) : (_S_IREAD | _S_IWRITE));
 
    /* there is no need to simulate _S_IEXEC using CMD's PATHEXT extensions */
    uxmode |= _S_IEXEC;
 
    return uxmode;
}

References fb().

Referenced by fileinfo_to_stat().

fileinfo_to_stat()

static int fileinfo_to_stat ( HANDLE  hFile, struct stat *  buf  )

static

Definition at line 68 of file win32stat.c.

{
    BY_HANDLE_FILE_INFORMATION fiData;
 
    memset(buf, 0, sizeof(*buf));
 
    /*
     * GetFileInformationByHandle minimum supported version: Windows XP and
     * Windows Server 2003, so it exists everywhere we care about.
     */
    if (!GetFileInformationByHandle(hFile, &fiData))
    {
        _dosmaperr(GetLastError());
        return -1;
    }
 
    if (fiData.ftLastWriteTime.dwLowDateTime ||
        fiData.ftLastWriteTime.dwHighDateTime)
        buf->st_mtime = filetime_to_time(&fiData.ftLastWriteTime);
 
    if (fiData.ftLastAccessTime.dwLowDateTime ||
        fiData.ftLastAccessTime.dwHighDateTime)
        buf->st_atime = filetime_to_time(&fiData.ftLastAccessTime);
    else
        buf->st_atime = buf->st_mtime;
 
    if (fiData.ftCreationTime.dwLowDateTime ||
        fiData.ftCreationTime.dwHighDateTime)
        buf->st_ctime = filetime_to_time(&fiData.ftCreationTime);
    else
        buf->st_ctime = buf->st_mtime;
 
    buf->st_mode = fileattr_to_unixmode(fiData.dwFileAttributes);
    buf->st_nlink = fiData.nNumberOfLinks;
 
    buf->st_size = ((((uint64) fiData.nFileSizeHigh) << 32) |
                    fiData.nFileSizeLow);
 
    return 0;
}

References _dosmaperr(), buf, fb(), fileattr_to_unixmode(), and filetime_to_time().

Referenced by _pgfstat64(), and _pglstat64().

filetime_to_time()

static __time64_t filetime_to_time ( const FILETIME *  ft )

static

Definition at line 25 of file win32stat.c.

{
    ULARGE_INTEGER unified_ft = {0};
    static const uint64 EpochShift = UINT64CONST(116444736000000000);
 
    unified_ft.LowPart = ft->dwLowDateTime;
    unified_ft.HighPart = ft->dwHighDateTime;
 
    if (unified_ft.QuadPart < EpochShift)
        return -1;
 
    unified_ft.QuadPart -= EpochShift;
    unified_ft.QuadPart /= 10 * 1000 * 1000;
 
    return unified_ft.QuadPart;
}

References fb(), and UINT64CONST.

Referenced by fileinfo_to_stat().