dir.c File Reference

#include <corecrt_io.h>
#include <mbctype.h>
#include <stdarg.h>
#include <stdlib.h>
#include <direct.h>
#include "windef.h"
#include "winbase.h"
#include "winternl.h"
#include "msvcrt.h"
#include "wine/debug.h"

Include dependency graph for dir.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msvcrt)
static void	msvcrt_fttofd (const WIN32_FIND_DATAA *fd, struct _finddata_t *ft)
static void	msvcrt_wfttofd (const WIN32_FIND_DATAW *fd, struct _wfinddata_t *ft)
static void	msvcrt_wfttofd32 (const WIN32_FIND_DATAW *fd, struct _wfinddata32_t *ft)
static void	msvcrt_fttofdi64 (const WIN32_FIND_DATAA *fd, struct _finddatai64_t *ft)
static void	msvcrt_wfttofd64 (const WIN32_FIND_DATAW *fd, struct _wfinddata64_t *ft)
static void	msvcrt_wfttofdi64 (const WIN32_FIND_DATAW *fd, struct _wfinddatai64_t *ft)
static void	msvcrt_wfttofd64i32 (const WIN32_FIND_DATAW *fd, struct _wfinddata64i32_t *ft)
int CDECL	_chdir (const char *newdir)
int CDECL	_wchdir (const wchar_t *newdir)
int CDECL	_chdrive (int newdrive)
int CDECL	_findclose (intptr_t hand)
intptr_t CDECL	_findfirst (const char *fspec, struct _finddata_t *ft)
intptr_t CDECL	_wfindfirst (const wchar_t *fspec, struct _wfinddata_t *ft)
intptr_t CDECL	_wfindfirst32 (const wchar_t *fspec, struct _wfinddata32_t *ft)
static int	finddata32_wtoa (const struct _wfinddata32_t *wfd, struct _finddata32_t *fd)
intptr_t CDECL	_findfirst32 (const char *fspec, struct _finddata32_t *ft)
intptr_t CDECL	_findfirsti64 (const char *fspec, struct _finddatai64_t *ft)
intptr_t CDECL	_wfindfirst64 (const wchar_t *fspec, struct _wfinddata64_t *ft)
static int	finddata64_wtoa (const struct _wfinddata64_t *wfd, struct _finddata64_t *fd)
intptr_t CDECL	_findfirst64 (const char *fspec, struct _finddata64_t *ft)
intptr_t CDECL	_wfindfirst64i32 (const wchar_t *fspec, struct _wfinddata64i32_t *ft)
static int	finddata64i32_wtoa (const struct _wfinddata64i32_t *wfd, struct _finddata64i32_t *fd)
intptr_t CDECL	_findfirst64i32 (const char *fspec, struct _finddata64i32_t *ft)
intptr_t CDECL	_wfindfirsti64 (const wchar_t *fspec, struct _wfinddatai64_t *ft)
int CDECL	_findnext (intptr_t hand, struct _finddata_t *ft)
int CDECL	_wfindnext32 (intptr_t hand, struct _wfinddata32_t *ft)
int CDECL	_findnext32 (intptr_t hand, struct _finddata32_t *ft)
int CDECL	_wfindnext (intptr_t hand, struct _wfinddata_t *ft)
int CDECL	_findnexti64 (intptr_t hand, struct _finddatai64_t *ft)
int CDECL	_wfindnext64 (intptr_t hand, struct _wfinddata64_t *ft)
int CDECL	_findnext64 (intptr_t hand, struct _finddata64_t *ft)
int CDECL	_wfindnexti64 (intptr_t hand, struct _wfinddatai64_t *ft)
int CDECL	_wfindnext64i32 (intptr_t hand, struct _wfinddata64i32_t *ft)
int CDECL	_findnext64i32 (intptr_t hand, struct _finddata64i32_t *ft)
char *CDECL	_getcwd (char *buf, int size)
wchar_t *CDECL	_wgetcwd (wchar_t *buf, int size)
int CDECL	_getdrive (void)
char *CDECL	_getdcwd (int drive, char *buf, int size)
wchar_t *CDECL	_wgetdcwd (int drive, wchar_t *buf, int size)
unsigned int CDECL	_getdiskfree (unsigned int disk, struct _diskfree_t *d)
int CDECL	_mkdir (const char *newdir)
int CDECL	_wmkdir (const wchar_t *newdir)
int CDECL	_rmdir (const char *dir)
int CDECL	_wrmdir (const wchar_t *dir)
errno_t CDECL	_splitpath_s (const char *inpath, char *drive, size_t sz_drive, char *dir, size_t sz_dir, char *fname, size_t sz_fname, char *ext, size_t sz_ext)
void CDECL	_splitpath (const char *inpath, char *drv, char *dir, char *fname, char *ext)
int CDECL	_wsplitpath_s (const wchar_t *inpath, wchar_t *drive, size_t sz_drive, wchar_t *dir, size_t sz_dir, wchar_t *fname, size_t sz_fname, wchar_t *ext, size_t sz_ext)
void CDECL	_wsplitpath (const wchar_t *inpath, wchar_t *drv, wchar_t *dir, wchar_t *fname, wchar_t *ext)
wchar_t *CDECL	_wfullpath (wchar_t *absPath, const wchar_t *relPath, size_t size)
char *CDECL	_fullpath (char *abs_path, const char *rel_path, size_t size)
VOID CDECL	_makepath (char *path, const char *drive, const char *directory, const char *filename, const char *extension)
VOID CDECL	_wmakepath (wchar_t *path, const wchar_t *drive, const wchar_t *directory, const wchar_t *filename, const wchar_t *extension)
int CDECL	_makepath_s (char *path, size_t size, const char *drive, const char *directory, const char *filename, const char *extension)
int CDECL	_wmakepath_s (wchar_t *path, size_t size, const wchar_t *drive, const wchar_t *directory, const wchar_t *filename, const wchar_t *extension)
int CDECL	_searchenv_s (const char *file, const char *env, char *buf, size_t count)
void CDECL	_searchenv (const char *file, const char *env, char *buf)
int CDECL	_wsearchenv_s (const wchar_t *file, const wchar_t *env, wchar_t *buf, size_t count)
void CDECL	_wsearchenv (const wchar_t *file, const wchar_t *env, wchar_t *buf)

Function Documentation

_chdir()

int CDECL _chdir

(

const char *

newdir

)

Definition at line 215 of file dir.c.

{
    wchar_t *newdirW = NULL;
    int ret;
 
    if (newdir && !(newdirW = wstrdupa_utf8(newdir))) return -1;
    ret = _wchdir(newdirW);
    free(newdirW);
    return ret;
}

Referenced by test_utf8().

_chdrive()

int CDECL _chdrive

(

int

newdrive

)

Definition at line 268 of file dir.c.

{
  WCHAR buffer[] = L"A:";
 
  buffer[0] += newdrive - 1;
  if (!SetCurrentDirectoryW( buffer ))
  {
    msvcrt_set_errno(GetLastError());
    if (newdrive <= 0)
      *_errno() = EACCES;
    return -1;
  }
  return 0;
}

_findclose()

int CDECL _findclose

(

intptr_t

hand

)

Definition at line 298 of file dir.c.

{
  TRACE(":handle %Iu\n",hand);
  if (!FindClose((HANDLE)hand))
  {
    msvcrt_set_errno(GetLastError());
    return -1;
  }
  return 0;
}

Referenced by _findfirst32(), _findfirst64(), _findfirst64i32(), main(), and test_utf8().

_findfirst()

intptr_t CDECL _findfirst	(	const char *	fspec,
		struct _finddata_t *	ft
	)

Definition at line 326 of file dir.c.

{
  WIN32_FIND_DATAA find_data;
  HANDLE hfind;
 
  hfind  = FindFirstFileA(fspec, &find_data);
  if (hfind == INVALID_HANDLE_VALUE)
  {
    msvcrt_set_errno(GetLastError());
    return -1;
  }
  msvcrt_fttofd(&find_data,ft);
  TRACE(":got handle %p\n",hfind);
  return (intptr_t)hfind;
}

_findfirst32()

intptr_t CDECL _findfirst32	(	const char *	fspec,
		struct _finddata32_t *	ft
	)

Definition at line 397 of file dir.c.

{
    struct _wfinddata32_t wft;
    wchar_t *fspecW = NULL;
    intptr_t ret;
 
    if (fspec && !(fspecW = wstrdupa_utf8(fspec))) return -1;
    ret = _wfindfirst32(fspecW, &wft);
    free(fspecW);
    if (ret != -1 && !finddata32_wtoa(&wft, ft))
    {
        _findclose(ret);
        return -1;
    }
    return ret;
}

Referenced by test_utf8().

_findfirst64()

intptr_t CDECL _findfirst64	(	const char *	fspec,
		struct _finddata64_t *	ft
	)

Definition at line 471 of file dir.c.

{
    struct _wfinddata64_t wft;
    wchar_t *fspecW = NULL;
    intptr_t ret;
 
    if (fspec && !(fspecW = wstrdupa_utf8(fspec))) return -1;
    ret = _wfindfirst64(fspecW, &wft);
    free(fspecW);
    if (ret != -1 && !finddata64_wtoa(&wft, ft))
    {
        _findclose(ret);
        return -1;
    }
    return ret;
}

_findfirst64i32()

intptr_t CDECL _findfirst64i32	(	const char *	fspec,
		struct _finddata64i32_t *	ft
	)

Definition at line 524 of file dir.c.

{
    struct _wfinddata64i32_t wft;
    wchar_t *fspecW = NULL;
    intptr_t ret;
 
    if (fspec && !(fspecW = wstrdupa_utf8(fspec))) return -1;
    ret = _wfindfirst64i32(fspecW, &wft);
    free(fspecW);
    if (ret != -1 && !finddata64i32_wtoa(&wft, ft))
    {
        _findclose(ret);
        return -1;
    }
    return ret;
}

_findfirsti64()

intptr_t CDECL _findfirsti64	(	const char *	fspec,
		struct _finddatai64_t *	ft
	)

Definition at line 419 of file dir.c.

{
  WIN32_FIND_DATAA find_data;
  HANDLE hfind;
 
  hfind  = FindFirstFileA(fspec, &find_data);
  if (hfind == INVALID_HANDLE_VALUE)
  {
    msvcrt_set_errno(GetLastError());
    return -1;
  }
  msvcrt_fttofdi64(&find_data,ft);
  TRACE(":got handle %p\n",hfind);
  return (intptr_t)hfind;
}

_findnext()

int CDECL _findnext	(	intptr_t	hand,
		struct _finddata_t *	ft
	)

Definition at line 578 of file dir.c.

{
  WIN32_FIND_DATAA find_data;
 
  if (!FindNextFileA((HANDLE)hand, &find_data))
  {
    *_errno() = ENOENT;
    return -1;
  }
 
  msvcrt_fttofd(&find_data,ft);
  return 0;
}

_findnext32()

int CDECL _findnext32	(	intptr_t	hand,
		struct _finddata32_t *	ft
	)

Definition at line 612 of file dir.c.

{
    struct _wfinddata32_t wft;
    int ret;
 
    ret = _wfindnext32(hand, &wft);
    if (!ret && !finddata32_wtoa(&wft, ft)) ret = -1;
    return ret;
}

Referenced by test_utf8().

_findnext64()

int CDECL _findnext64	(	intptr_t	hand,
		struct _finddata64_t *	ft
	)

Definition at line 684 of file dir.c.

{
    struct _wfinddata64_t wft;
    int ret;
 
    ret = _wfindnext64(hand, &wft);
    if (!ret && !finddata64_wtoa(&wft, ft)) ret = -1;
    return ret;
}

_findnext64i32()

int CDECL _findnext64i32	(	intptr_t	hand,
		struct _finddata64i32_t *	ft
	)

Definition at line 737 of file dir.c.

{
    struct _wfinddata64i32_t wft;
    int ret;
 
    ret = _wfindnext64i32(hand, &wft);
    if (!ret && !finddata64i32_wtoa(&wft, ft)) ret = -1;
    return ret;
}

_findnexti64()

int CDECL _findnexti64	(	intptr_t	hand,
		struct _finddatai64_t *	ft
	)

Definition at line 646 of file dir.c.

{
  WIN32_FIND_DATAA find_data;
 
  if (!FindNextFileA((HANDLE)hand, &find_data))
  {
    *_errno() = ENOENT;
    return -1;
  }
 
  msvcrt_fttofdi64(&find_data,ft);
  return 0;
}

_fullpath()

char *CDECL _fullpath	(	char *	abs_path,
		const char *	rel_path,
		size_t	size
	)

Definition at line 1272 of file dir.c.

{
    wchar_t abs_pathW[MAX_PATH], *rel_pathW = NULL, *retW;
    size_t len;
 
    if (rel_path && !(rel_pathW = wstrdupa_utf8(rel_path))) return NULL;
    retW = _wfullpath(abs_pathW, rel_pathW, ARRAY_SIZE(abs_pathW));
    free(rel_pathW);
    if (!retW) return NULL;
 
    if (!abs_path) return astrdupw_utf8(abs_pathW);
    len = convert_wcs_to_acp_utf8(abs_pathW, NULL, 0);
    if (!len) return NULL;
    if (len > size)
    {
        *_errno() = ERANGE;
        return NULL;
    }
    convert_wcs_to_acp_utf8(abs_pathW, abs_path, size);
    return abs_path;
}

Referenced by _searchenv_s(), test_fullpath(), and test_utf8().

_getcwd()

char *CDECL _getcwd	(	char *	buf,
		int	size
	)

Definition at line 761 of file dir.c.

{
    wchar_t dirW[MAX_PATH];
    int len;
 
    if (!_wgetcwd(dirW, ARRAY_SIZE(dirW))) return NULL;
 
    if (!buf) return astrdupw_utf8(dirW);
    len = convert_wcs_to_acp_utf8(dirW, NULL, 0);
    if (!len) return NULL;
    if (len > size)
    {
        *_errno() = ERANGE;
        return NULL;
    }
    convert_wcs_to_acp_utf8(dirW, buf, size);
    return buf;
}

Referenced by test_utf8().

_getdcwd()

char *CDECL _getdcwd	(	int	drive,
		char *	buf,
		int	size
	)

Definition at line 843 of file dir.c.

{
    wchar_t dirW[MAX_PATH];
    int len;
 
    if (!_wgetdcwd(drive, dirW, ARRAY_SIZE(dirW))) return NULL;
 
    if (!buf) return astrdupw_utf8(dirW);
    len = convert_wcs_to_acp_utf8(dirW, NULL, 0);
    if (!len) return NULL;
    if (len > size)
    {
        *_errno() = ERANGE;
        return NULL;
    }
    convert_wcs_to_acp_utf8(dirW, buf, size);
    return buf;
}

Referenced by test_utf8().

_getdiskfree()

unsigned int CDECL _getdiskfree	(	unsigned int	disk,
		struct _diskfree_t *	d
	)

Definition at line 919 of file dir.c.

{
  WCHAR drivespec[] = L"@:\\";
  DWORD ret[4];
  unsigned int err;
 
  if (disk > 26)
    return ERROR_INVALID_PARAMETER; /* MSVCRT doesn't set errno here */
 
  drivespec[0] += disk; /* make a drive letter */
 
  if (GetDiskFreeSpaceW(disk==0?NULL:drivespec,ret,ret+1,ret+2,ret+3))
  {
    d->sectors_per_cluster = ret[0];
    d->bytes_per_sector = ret[1];
    d->avail_clusters = ret[2];
    d->total_clusters = ret[3];
    return 0;
  }
  err = GetLastError();
  msvcrt_set_errno(err);
  return err;
}

_getdrive()

int CDECL _getdrive

(

void

)

Definition at line 819 of file dir.c.

{
    WCHAR buffer[MAX_PATH];
    if (GetCurrentDirectoryW( MAX_PATH, buffer ) &&
        buffer[0] >= 'A' && buffer[0] <= 'z' && buffer[1] == ':')
        return towupper(buffer[0]) - 'A' + 1;
    return 0;
}

Referenced by _tgetdcwd(), _tstat64(), _wgetdcwd(), _wstat64(), cmd_setlocal(), get_drive_number_from_path(), test_utf8(), and throw().

_makepath()

VOID CDECL _makepath	(	char *	path,
		const char *	drive,
		const char *	directory,
		const char *	filename,
		const char *	extension
	)

Definition at line 1310 of file dir.c.

{
    char *p = path;
 
    TRACE("(%s %s %s %s)\n", debugstr_a(drive), debugstr_a(directory),
          debugstr_a(filename), debugstr_a(extension) );
 
    if ( !path )
        return;
 
    if (drive && drive[0])
    {
        *p++ = drive[0];
        *p++ = ':';
    }
    if (directory && directory[0])
    {
        unsigned int len = strlen(directory);
        memmove(p, directory, len);
        p += len;
        if (p[-1] != '/' && p[-1] != '\\')
            *p++ = '\\';
    }
    if (filename && filename[0])
    {
        unsigned int len = strlen(filename);
        memmove(p, filename, len);
        p += len;
    }
    if (extension && extension[0])
    {
        if (extension[0] != '.')
            *p++ = '.';
        strcpy(p, extension);
    }
    else
        *p = '\0';
    TRACE("returning %s\n",path);
}

_makepath_s()

int CDECL _makepath_s	(	char *	path,
		size_t	size,
		const char *	drive,
		const char *	directory,
		const char *	filename,
		const char *	extension
	)

Definition at line 1404 of file dir.c.

{
    char *p = path;
 
    if (!path || !size)
    {
        *_errno() = EINVAL;
        return EINVAL;
    }
 
    if (drive && drive[0])
    {
        if (size <= 2)
            goto range;
 
        *p++ = drive[0];
        *p++ = ':';
        size -= 2;
    }
 
    if (directory && directory[0])
    {
        unsigned int len = strlen(directory);
        unsigned int needs_separator = directory[len - 1] != '/' && directory[len - 1] != '\\';
        unsigned int copylen = min(size - 1, len);
 
        if (size < 2)
            goto range;
 
        memmove(p, directory, copylen);
 
        if (size <= len)
            goto range;
 
        p += copylen;
        size -= copylen;
 
        if (needs_separator)
        {
            if (size < 2)
                goto range;
 
            *p++ = '\\';
            size -= 1;
        }
    }
 
    if (filename && filename[0])
    {
        unsigned int len = strlen(filename);
        unsigned int copylen = min(size - 1, len);
 
        if (size < 2)
            goto range;
 
        memmove(p, filename, copylen);
 
        if (size <= len)
            goto range;
 
        p += len;
        size -= len;
    }
 
    if (extension && extension[0])
    {
        unsigned int len = strlen(extension);
        unsigned int needs_period = extension[0] != '.';
        unsigned int copylen;
 
        if (size < 2)
            goto range;
 
        if (needs_period)
        {
            *p++ = '.';
            size -= 1;
        }
 
        copylen = min(size - 1, len);
        memcpy(p, extension, copylen);
 
        if (size <= len)
            goto range;
 
        p += copylen;
    }
 
    *p = '\0';
    return 0;
 
range:
    path[0] = '\0';
    *_errno() = ERANGE;
    return ERANGE;
}

_mkdir()

int CDECL _mkdir

(

const char *

newdir

)

Definition at line 958 of file dir.c.

{
    wchar_t *newdirW = NULL;
    int ret;
 
    if (newdir && !(newdirW = wstrdupa_utf8(newdir))) return -1;
    ret = _wmkdir(newdirW);
    free(newdirW);
    return ret;
}

Referenced by rd_pstcache_mkdir(), test___getmainargs_parent(), and test_utf8().

_rmdir()

int CDECL _rmdir

(

const char *

dir

)

Definition at line 997 of file dir.c.

{
    wchar_t *dirW = NULL;
    int ret;
 
    if (dir && !(dirW = wstrdupa_utf8(dir))) return -1;
    ret = _wrmdir(dirW);
    free(dirW);
    return ret;
}

Referenced by test___getmainargs_parent().

_searchenv()

void CDECL _searchenv	(	const char *	file,
		const char *	env,
		char *	buf
	)

Definition at line 1702 of file dir.c.

{
    _searchenv_s(file, env, buf, MAX_PATH);
}

Referenced by TConfig::keyfile_init(), test_searchenv(), and test_utf8().

_searchenv_s()

int CDECL _searchenv_s	(	const char *	file,
		const char *	env,
		char *	buf,
		size_t	count
	)

Definition at line 1610 of file dir.c.

{
  char *envVal, *penv, *end;
  char path[MAX_PATH];
  size_t path_len, fname_len;
  int old_errno, access;
 
  if (!MSVCRT_CHECK_PMT(file != NULL)) return EINVAL;
  if (!MSVCRT_CHECK_PMT(buf != NULL)) return EINVAL;
  if (!MSVCRT_CHECK_PMT(count > 0)) return EINVAL;
 
  if (count > MAX_PATH)
      FIXME("count > MAX_PATH not supported\n");
 
  fname_len = strlen(file);
  *buf = '\0';
 
  /* Try CWD first */
  old_errno = *_errno();
  access = _access(file, 0);
  *_errno() = old_errno;
  if (!access)
  {
    if (!_fullpath(buf, file, count))
      return *_errno();
    return 0;
  }
 
  /* Search given environment variable */
  envVal = getenv(env);
  if (!envVal)
  {
    *_errno() = ENOENT;
    return ENOENT;
  }
 
  penv = envVal;
  TRACE(":searching for %s in paths %s\n", file, envVal);
 
  for(; *penv; penv = (*end ? end + 1 : end))
  {
    end = penv;
    path_len = 0;
    while(*end && *end != ';' && path_len < MAX_PATH)
    {
        if (*end == '"')
        {
            end++;
            while(*end && *end != '"' && path_len < MAX_PATH)
            {
                path[path_len++] = *end;
                end++;
            }
            if (*end == '"') end++;
            continue;
        }
 
        path[path_len++] = *end;
        end++;
    }
    if (!path_len || path_len >= MAX_PATH)
      continue;
 
    if (path[path_len - 1] != '/' && path[path_len - 1] != '\\')
      path[path_len++] = '\\';
    if (path_len + fname_len >= MAX_PATH)
      continue;
 
    memcpy(path + path_len, file, fname_len + 1);
    TRACE("Checking for file %s\n", path);
    old_errno = *_errno();
    access = _access(path, 0);
    *_errno() = old_errno;
    if (!access)
    {
      if (path_len + fname_len + 1 > count)
      {
        MSVCRT_INVALID_PMT("buf[count] is too small", ERANGE);
        return ERANGE;
      }
      memcpy(buf, path, path_len + fname_len + 1);
      return 0;
    }
  }
 
  *_errno() = ENOENT;
  return ENOENT;
}

Referenced by _searchenv().

_splitpath()

void CDECL _splitpath	(	const char *	inpath,
		char *	drv,
		char *	dir,
		char *	fname,
		char *	ext
	)

Definition at line 1112 of file dir.c.

{
    _splitpath_s(inpath, drv, drv ? _MAX_DRIVE : 0, dir, dir ? _MAX_DIR : 0,
            fname, fname ? _MAX_FNAME : 0, ext, ext ? _MAX_EXT : 0);
}

Referenced by START_TEST(), and test_splitpath().

_splitpath_s()

errno_t CDECL _splitpath_s	(	const char *	inpath,
		char *	drive,
		size_t	sz_drive,
		char *	dir,
		size_t	sz_dir,
		char *	fname,
		size_t	sz_fname,
		char *	ext,
		size_t	sz_ext
	)

Definition at line 1024 of file dir.c.

{
    const char *p, *end;
 
    if (!inpath || (!drive && sz_drive) ||
            (drive && !sz_drive) ||
            (!dir && sz_dir) ||
            (dir && !sz_dir) ||
            (!fname && sz_fname) ||
            (fname && !sz_fname) ||
            (!ext && sz_ext) ||
            (ext && !sz_ext))
    {
        *_errno() = EINVAL;
        return EINVAL;
    }
 
    if (inpath[0] && inpath[1] == ':')
    {
        if (drive)
        {
            if (sz_drive <= 2) goto do_error;
            drive[0] = inpath[0];
            drive[1] = inpath[1];
            drive[2] = 0;
        }
        inpath += 2;
    }
    else if (drive) drive[0] = '\0';
 
    /* look for end of directory part */
    end = NULL;
    for (p = inpath; *p; p++)
    {
        if (_ismbblead((unsigned char)*p))
        {
            p++;
            continue;
        }
        if (*p == '/' || *p == '\\') end = p + 1;
    }
 
    if (end)  /* got a directory */
    {
        if (dir)
        {
            if (sz_dir <= end - inpath) goto do_error;
            memcpy( dir, inpath, (end - inpath) );
            dir[end - inpath] = 0;
        }
        inpath = end;
    }
    else if (dir) dir[0] = 0;
 
    /* look for extension: what's after the last dot */
    end = NULL;
    for (p = inpath; *p; p++) if (*p == '.') end = p;
 
    if (!end) end = p; /* there's no extension */
 
    if (fname)
    {
        if (sz_fname <= end - inpath) goto do_error;
        memcpy( fname, inpath, (end - inpath) );
        fname[end - inpath] = 0;
    }
    if (ext)
    {
        if (sz_ext <= strlen(end)) goto do_error;
        strcpy( ext, end );
    }
    return 0;
do_error:
    if (drive)  drive[0] = '\0';
    if (dir)    dir[0] = '\0';
    if (fname)  fname[0]= '\0';
    if (ext)    ext[0]= '\0';
    *_errno() = ERANGE;
    return ERANGE;
}

_wchdir()

int CDECL _wchdir

(

const wchar_t *

newdir

)

This file has no copyright assigned and is placed in the Public Domain. This file is part of the Wine project.

Definition at line 231 of file dir.c.

{
  if (!SetCurrentDirectoryW(newdir))
  {
    msvcrt_set_errno(newdir?GetLastError():0);
    return -1;
  }
#ifdef __REACTOS__
    /* Update the drive-specific current directory variable */
    WCHAR fulldir[MAX_PATH];
    if (GetCurrentDirectoryW(ARRAYSIZE(fulldir), fulldir) >= 2)
    {
        if (fulldir[1] == L':')
        {
            WCHAR envvar[4] = { L'=', towupper(fulldir[0]), L':', L'\0' };
            SetEnvironmentVariableW(envvar, fulldir);
        }
    }
#endif
  return 0;
}

Referenced by _chdir().

_wfindfirst()

intptr_t CDECL _wfindfirst	(	const wchar_t *	fspec,
		struct _wfinddata_t *	ft
	)

Definition at line 347 of file dir.c.

{
  WIN32_FIND_DATAW find_data;
  HANDLE hfind;
 
  hfind  = FindFirstFileW(fspec, &find_data);
  if (hfind == INVALID_HANDLE_VALUE)
  {
    msvcrt_set_errno(GetLastError());
    return -1;
  }
  msvcrt_wfttofd(&find_data,ft);
  TRACE(":got handle %p\n",hfind);
  return (intptr_t)hfind;
}

_wfindfirst32()

intptr_t CDECL _wfindfirst32	(	const wchar_t *	fspec,
		struct _wfinddata32_t *	ft
	)

Definition at line 368 of file dir.c.

{
  WIN32_FIND_DATAW find_data;
  HANDLE hfind;
 
  hfind = FindFirstFileW(fspec, &find_data);
  if (hfind == INVALID_HANDLE_VALUE)
  {
    msvcrt_set_errno(GetLastError());
    return -1;
  }
  msvcrt_wfttofd32(&find_data, ft);
  TRACE(":got handle %p\n", hfind);
  return (intptr_t)hfind;
}

Referenced by _findfirst32().

_wfindfirst64()

intptr_t CDECL _wfindfirst64	(	const wchar_t *	fspec,
		struct _wfinddata64_t *	ft
	)

Definition at line 440 of file dir.c.

{
  WIN32_FIND_DATAW find_data;
  HANDLE hfind;
 
  hfind  = FindFirstFileW(fspec, &find_data);
  if (hfind == INVALID_HANDLE_VALUE)
  {
    msvcrt_set_errno(GetLastError());
    return -1;
  }
  msvcrt_wfttofd64(&find_data,ft);
  TRACE(":got handle %p\n",hfind);
  return (intptr_t)hfind;
}

_wfindfirst64i32()

intptr_t CDECL _wfindfirst64i32	(	const wchar_t *	fspec,
		struct _wfinddata64i32_t *	ft
	)

Definition at line 493 of file dir.c.

{
  WIN32_FIND_DATAW find_data;
  HANDLE hfind;
 
  hfind  = FindFirstFileW(fspec, &find_data);
  if (hfind == INVALID_HANDLE_VALUE)
  {
    msvcrt_set_errno(GetLastError());
    return -1;
  }
  msvcrt_wfttofd64i32(&find_data,ft);
  TRACE(":got handle %p\n",hfind);
  return (intptr_t)hfind;
}

_wfindfirsti64()

intptr_t CDECL _wfindfirsti64	(	const wchar_t *	fspec,
		struct _wfinddatai64_t *	ft
	)

Definition at line 546 of file dir.c.

{
  WIN32_FIND_DATAW find_data;
  HANDLE hfind;
 
  hfind  = FindFirstFileW(fspec, &find_data);
  if (hfind == INVALID_HANDLE_VALUE)
  {
    msvcrt_set_errno(GetLastError());
    return -1;
  }
  msvcrt_wfttofdi64(&find_data,ft);
  TRACE(":got handle %p\n",hfind);
  return (intptr_t)hfind;
}

_wfindnext()

int CDECL _wfindnext	(	intptr_t	hand,
		struct _wfinddata_t *	ft
	)

Definition at line 627 of file dir.c.

{
  WIN32_FIND_DATAW find_data;
 
  if (!FindNextFileW((HANDLE)hand, &find_data))
  {
    *_errno() = ENOENT;
    return -1;
  }
 
  msvcrt_wfttofd(&find_data,ft);
  return 0;
}

_wfindnext32()

int CDECL _wfindnext32	(	intptr_t	hand,
		struct _wfinddata32_t *	ft
	)

Definition at line 595 of file dir.c.

{
  WIN32_FIND_DATAW find_data;
 
  if (!FindNextFileW((HANDLE)hand, &find_data))
  {
    *_errno() = ENOENT;
    return -1;
  }
 
  msvcrt_wfttofd32(&find_data, ft);
  return 0;
}

Referenced by _findnext32().

_wfindnext64()

int CDECL _wfindnext64	(	intptr_t	hand,
		struct _wfinddata64_t *	ft
	)

Definition at line 665 of file dir.c.

{
  WIN32_FIND_DATAW find_data;
 
  if (!FindNextFileW((HANDLE)hand, &find_data))
  {
    *_errno() = ENOENT;
    return -1;
  }
 
  msvcrt_wfttofd64(&find_data,ft);
  return 0;
}

_wfindnext64i32()

int CDECL _wfindnext64i32	(	intptr_t	hand,
		struct _wfinddata64i32_t *	ft
	)

Definition at line 718 of file dir.c.

{
  WIN32_FIND_DATAW find_data;
 
  if (!FindNextFileW((HANDLE)hand, &find_data))
  {
    *_errno() = ENOENT;
    return -1;
  }
 
  msvcrt_wfttofd64i32(&find_data,ft);
  return 0;
}

_wfindnexti64()

int CDECL _wfindnexti64	(	intptr_t	hand,
		struct _wfinddatai64_t *	ft
	)

Definition at line 699 of file dir.c.

{
  WIN32_FIND_DATAW find_data;
 
  if (!FindNextFileW((HANDLE)hand, &find_data))
  {
    *_errno() = ENOENT;
    return -1;
  }
 
  msvcrt_wfttofdi64(&find_data,ft);
  return 0;
}

_wfullpath()

wchar_t *CDECL _wfullpath	(	wchar_t *	absPath,
		const wchar_t *	relPath,
		size_t	size
	)

Definition at line 1218 of file dir.c.

{
  DWORD rc;
  WCHAR* buffer;
  WCHAR* lastpart;
  BOOL alloced = FALSE;
 
  if (!relPath || !*relPath)
    return _wgetcwd(absPath, size);
 
  if (absPath == NULL)
  {
      buffer = malloc(MAX_PATH * sizeof(WCHAR));
      size = MAX_PATH;
      alloced = TRUE;
  }
  else
      buffer = absPath;
 
  if (size < 4)
  {
    *_errno() = ERANGE;
    return NULL;
  }
 
  TRACE(":resolving relative path %s\n",debugstr_w(relPath));
 
  rc = GetFullPathNameW(relPath,size,buffer,&lastpart);
 
  if (rc > 0 && rc <= size )
    return buffer;
  else
  {
      if (alloced)
          free(buffer);
        return NULL;
  }
}

Referenced by _fullpath(), _wsearchenv_s(), and throw().

_wgetcwd()

wchar_t *CDECL _wgetcwd	(	wchar_t *	buf,
		int	size
	)

Definition at line 785 of file dir.c.

{
  wchar_t dir[MAX_PATH];
  int dir_len = GetCurrentDirectoryW(MAX_PATH,dir);
 
  if (dir_len < 1)
    return NULL; /* FIXME: Real return value untested */
 
  if (!buf)
  {
      if (size <= dir_len) size = dir_len + 1;
      if (!(buf = malloc( size * sizeof(WCHAR) ))) return NULL;
  }
  else if (dir_len >= size)
  {
    *_errno() = ERANGE;
    return NULL; /* buf too small */
  }
  wcscpy(buf,dir);
  return buf;
}

Referenced by _getcwd(), _wfullpath(), and _wgetdcwd().

_wgetdcwd()

wchar_t *CDECL _wgetdcwd	(	int	drive,
		wchar_t *	buf,
		int	size
	)

Definition at line 867 of file dir.c.

{
  static wchar_t* dummy;
 
  TRACE(":drive %d(%c), size %d\n",drive, drive + 'A' - 1, size);
 
  if (!drive || drive == _getdrive())
    return _wgetcwd(buf,size); /* current */
  else
  {
    wchar_t dir[MAX_PATH];
    wchar_t drivespec[4] = L"A:\\";
    int dir_len;
 
    drivespec[0] += drive - 1;
    if (GetDriveTypeW(drivespec) < DRIVE_REMOVABLE)
    {
      *_errno() = EACCES;
      return NULL;
    }
 
    dir_len = GetFullPathNameW(drivespec,MAX_PATH,dir,&dummy);
    if (dir_len >= size || dir_len < 1)
    {
      *_errno() = ERANGE;
      return NULL; /* buf too small */
    }
 
    TRACE(":returning %s\n", debugstr_w(dir));
    if (!buf)
      return _wcsdup(dir); /* allocate */
    wcscpy(buf,dir);
  }
  return buf;
}

Referenced by _getdcwd().

_wmakepath()

VOID CDECL _wmakepath	(	wchar_t *	path,
		const wchar_t *	drive,
		const wchar_t *	directory,
		const wchar_t *	filename,
		const wchar_t *	extension
	)

Definition at line 1357 of file dir.c.

{
    wchar_t *p = path;
 
    TRACE("%s %s %s %s\n", debugstr_w(drive), debugstr_w(directory),
          debugstr_w(filename), debugstr_w(extension));
 
    if ( !path )
        return;
 
    if (drive && drive[0])
    {
        *p++ = drive[0];
        *p++ = ':';
    }
    if (directory && directory[0])
    {
        unsigned int len = wcslen(directory);
        memmove(p, directory, len * sizeof(wchar_t));
        p += len;
        if (p[-1] != '/' && p[-1] != '\\')
            *p++ = '\\';
    }
    if (filename && filename[0])
    {
        unsigned int len = wcslen(filename);
        memmove(p, filename, len * sizeof(wchar_t));
        p += len;
    }
    if (extension && extension[0])
    {
        if (extension[0] != '.')
            *p++ = '.';
        wcscpy(p, extension);
    }
    else
        *p = '\0';
 
    TRACE("returning %s\n", debugstr_w(path));
}

Referenced by test_makepath().

_wmakepath_s()

int CDECL _wmakepath_s	(	wchar_t *	path,
		size_t	size,
		const wchar_t *	drive,
		const wchar_t *	directory,
		const wchar_t *	filename,
		const wchar_t *	extension
	)

Definition at line 1508 of file dir.c.

{
    wchar_t *p = path;
 
    if (!path || !size)
    {
        *_errno() = EINVAL;
        return EINVAL;
    }
 
    if (drive && drive[0])
    {
        if (size <= 2)
            goto range;
 
        *p++ = drive[0];
        *p++ = ':';
        size -= 2;
    }
 
    if (directory && directory[0])
    {
        unsigned int len = wcslen(directory);
        unsigned int needs_separator = directory[len - 1] != '/' && directory[len - 1] != '\\';
        unsigned int copylen = min(size - 1, len);
 
        if (size < 2)
            goto range;
 
        memmove(p, directory, copylen * sizeof(wchar_t));
 
        if (size <= len)
            goto range;
 
        p += copylen;
        size -= copylen;
 
        if (needs_separator)
        {
            if (size < 2)
                goto range;
 
            *p++ = '\\';
            size -= 1;
        }
    }
 
    if (filename && filename[0])
    {
        unsigned int len = wcslen(filename);
        unsigned int copylen = min(size - 1, len);
 
        if (size < 2)
            goto range;
 
        memmove(p, filename, copylen * sizeof(wchar_t));
 
        if (size <= len)
            goto range;
 
        p += len;
        size -= len;
    }
 
    if (extension && extension[0])
    {
        unsigned int len = wcslen(extension);
        unsigned int needs_period = extension[0] != '.';
        unsigned int copylen;
 
        if (size < 2)
            goto range;
 
        if (needs_period)
        {
            *p++ = '.';
            size -= 1;
        }
 
        copylen = min(size - 1, len);
        memcpy(p, extension, copylen * sizeof(wchar_t));
 
        if (size <= len)
            goto range;
 
        p += copylen;
    }
 
    *p = '\0';
    return 0;
 
range:
    path[0] = '\0';
    *_errno() = ERANGE;
    return ERANGE;
}

_wmkdir()

int CDECL _wmkdir

(

const wchar_t *

newdir

)

Definition at line 974 of file dir.c.

{
  if (CreateDirectoryW(newdir,NULL))
    return 0;
  msvcrt_set_errno(GetLastError());
  return -1;
}

Referenced by _mkdir().

_wrmdir()

int CDECL _wrmdir

(

const wchar_t *

dir

)

Definition at line 1013 of file dir.c.

{
  if (RemoveDirectoryW(dir))
    return 0;
  msvcrt_set_errno(GetLastError());
  return -1;
}

Referenced by _rmdir(), and test_utf8().

_wsearchenv()

void CDECL _wsearchenv	(	const wchar_t *	file,
		const wchar_t *	env,
		wchar_t *	buf
	)

Definition at line 1796 of file dir.c.

{
    _wsearchenv_s(file, env, buf, MAX_PATH);
}

Referenced by test_searchenv().

_wsearchenv_s()

int CDECL _wsearchenv_s	(	const wchar_t *	file,
		const wchar_t *	env,
		wchar_t *	buf,
		size_t	count
	)

Definition at line 1710 of file dir.c.

{
  wchar_t *envVal, *penv, *end;
  wchar_t path[MAX_PATH];
  size_t path_len, fname_len;
 
  if (!MSVCRT_CHECK_PMT(file != NULL)) return EINVAL;
  if (!MSVCRT_CHECK_PMT(buf != NULL)) return EINVAL;
  if (!MSVCRT_CHECK_PMT(count > 0)) return EINVAL;
 
  if (count > MAX_PATH)
      FIXME("count > MAX_PATH not supported\n");
 
  fname_len = wcslen(file);
  *buf = '\0';
 
  /* Try CWD first */
  if (GetFileAttributesW( file ) != INVALID_FILE_ATTRIBUTES)
  {
    if (!_wfullpath(buf, file, count))
        return *_errno();
    return 0;
  }
 
  /* Search given environment variable */
  envVal = _wgetenv(env);
  if (!envVal)
  {
    *_errno() = ENOENT;
    return ENOENT;
  }
 
  penv = envVal;
  TRACE(":searching for %s in paths %s\n", debugstr_w(file), debugstr_w(envVal));
 
  for(; *penv; penv = (*end ? end + 1 : end))
  {
    end = penv;
    path_len = 0;
    while(*end && *end != ';' && path_len < MAX_PATH)
    {
        if (*end == '"')
        {
            end++;
            while(*end && *end != '"' && path_len < MAX_PATH)
            {
                path[path_len++] = *end;
                end++;
            }
            if (*end == '"') end++;
            continue;
        }
 
        path[path_len++] = *end;
        end++;
    }
    if (!path_len || path_len >= MAX_PATH)
      continue;
 
    if (path[path_len - 1] != '/' && path[path_len - 1] != '\\')
      path[path_len++] = '\\';
    if (path_len + fname_len >= MAX_PATH)
      continue;
 
    memcpy(path + path_len, file, (fname_len + 1) * sizeof(wchar_t));
    TRACE("Checking for file %s\n", debugstr_w(path));
    if (GetFileAttributesW( path ) != INVALID_FILE_ATTRIBUTES)
    {
      if (path_len + fname_len + 1 > count)
      {
        MSVCRT_INVALID_PMT("buf[count] is too small", ERANGE);
        return ERANGE;
      }
      memcpy(buf, path, (path_len + fname_len + 1) * sizeof(wchar_t));
      return 0;
    }
  }
 
  *_errno() = ENOENT;
  return ENOENT;
}

Referenced by _wsearchenv().

_wsplitpath()

void CDECL _wsplitpath	(	const wchar_t *	inpath,
		wchar_t *	drv,
		wchar_t *	dir,
		wchar_t *	fname,
		wchar_t *	ext
	)

Definition at line 1206 of file dir.c.

{
    _wsplitpath_s(inpath, drv, drv ? _MAX_DRIVE : 0, dir, dir ? _MAX_DIR : 0,
            fname, fname ? _MAX_FNAME : 0, ext, ext ? _MAX_EXT : 0);
}

Referenced by ExplorerCmd::EvaluateOption(), GetSystemDrive(), UXTHEME_FormatParseMessage(), and XCOPY_ProcessDestParm().

_wsplitpath_s()

int CDECL _wsplitpath_s	(	const wchar_t *	inpath,
		wchar_t *	drive,
		size_t	sz_drive,
		wchar_t *	dir,
		size_t	sz_dir,
		wchar_t *	fname,
		size_t	sz_fname,
		wchar_t *	ext,
		size_t	sz_ext
	)

Definition at line 1124 of file dir.c.

{
    const wchar_t *p, *end;
 
    if (!inpath || (!drive && sz_drive) ||
            (drive && !sz_drive) ||
            (!dir && sz_dir) ||
            (dir && !sz_dir) ||
            (!fname && sz_fname) ||
            (fname && !sz_fname) ||
            (!ext && sz_ext) ||
            (ext && !sz_ext))
    {
        *_errno() = EINVAL;
        return EINVAL;
    }
 
    if (inpath[0] && inpath[1] == ':')
    {
        if (drive)
        {
            if (sz_drive <= 2) goto do_error;
            drive[0] = inpath[0];
            drive[1] = inpath[1];
            drive[2] = 0;
        }
        inpath += 2;
    }
    else if (drive) drive[0] = '\0';
 
    /* look for end of directory part */
    end = NULL;
    for (p = inpath; *p; p++) if (*p == '/' || *p == '\\') end = p + 1;
 
    if (end)  /* got a directory */
    {
        if (dir)
        {
            if (sz_dir <= end - inpath) goto do_error;
            memcpy( dir, inpath, (end - inpath) * sizeof(wchar_t) );
            dir[end - inpath] = 0;
        }
        inpath = end;
    }
    else if (dir) dir[0] = 0;
 
    /* look for extension: what's after the last dot */
    end = NULL;
    for (p = inpath; *p; p++) if (*p == '.') end = p;
 
    if (!end) end = p; /* there's no extension */
 
    if (fname)
    {
        if (sz_fname <= end - inpath) goto do_error;
        memcpy( fname, inpath, (end - inpath) * sizeof(wchar_t) );
        fname[end - inpath] = 0;
    }
    if (ext)
    {
        if (sz_ext <= wcslen(end)) goto do_error;
        wcscpy( ext, end );
    }
    return 0;
do_error:
    if (drive)  drive[0] = '\0';
    if (dir)    dir[0] = '\0';
    if (fname)  fname[0]= '\0';
    if (ext)    ext[0]= '\0';
    *_errno() = ERANGE;
    return ERANGE;
}

finddata32_wtoa()

static int finddata32_wtoa ( const struct _wfinddata32_t *  wfd, struct _finddata32_t *  fd  )

static

Definition at line 384 of file dir.c.

{
    fd->attrib = wfd->attrib;
    fd->time_create = wfd->time_create;
    fd->time_access = wfd->time_access;
    fd->time_write = wfd->time_write;
    fd->size = wfd->size;
    return convert_wcs_to_acp_utf8(wfd->name, fd->name, ARRAY_SIZE(fd->name));
}

Referenced by _findfirst32(), and _findnext32().

finddata64_wtoa()

static int finddata64_wtoa ( const struct _wfinddata64_t *  wfd, struct _finddata64_t *  fd  )

static

Definition at line 456 of file dir.c.

{
    fd->attrib = wfd->attrib;
    fd->time_create = wfd->time_create;
    fd->time_access = wfd->time_access;
    fd->time_write = wfd->time_write;
    fd->size = wfd->size;
    return convert_wcs_to_acp_utf8(wfd->name, fd->name, ARRAY_SIZE(fd->name));
}

Referenced by _findfirst64(), and _findnext64().

finddata64i32_wtoa()

static int finddata64i32_wtoa ( const struct _wfinddata64i32_t *  wfd, struct _finddata64i32_t *  fd  )

static

Definition at line 509 of file dir.c.

{
    fd->attrib = wfd->attrib;
    fd->time_create = wfd->time_create;
    fd->time_access = wfd->time_access;
    fd->time_write = wfd->time_write;
    fd->size = wfd->size;
    return convert_wcs_to_acp_utf8(wfd->name, fd->name, ARRAY_SIZE(fd->name));
}

Referenced by _findfirst64i32(), and _findnext64i32().

msvcrt_fttofd()

static void msvcrt_fttofd ( const WIN32_FIND_DATAA *  fd, struct _finddata_t *  ft  )

static

Definition at line 61 of file dir.c.

{
  DWORD dw;
 
  if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
    ft->attrib = 0;
  else
    ft->attrib = fd->dwFileAttributes;
 
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw );
  ft->time_create = dw;
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
  ft->time_access = dw;
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
  ft->time_write = dw;
  ft->size = fd->nFileSizeLow;
  strcpy(ft->name, fd->cFileName);
}

Referenced by _findfirst(), and _findnext().

msvcrt_fttofdi64()

static void msvcrt_fttofdi64 ( const WIN32_FIND_DATAA *  fd, struct _finddatai64_t *  ft  )

static

Definition at line 121 of file dir.c.

{
  DWORD dw;
 
  if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
    ft->attrib = 0;
  else
    ft->attrib = fd->dwFileAttributes;
 
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw );
  ft->time_create = dw;
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
  ft->time_access = dw;
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
  ft->time_write = dw;
  ft->size = ((__int64)fd->nFileSizeHigh) << 32 | fd->nFileSizeLow;
  strcpy(ft->name, fd->cFileName);
}

Referenced by _findfirsti64(), and _findnexti64().

msvcrt_wfttofd()

static void msvcrt_wfttofd ( const WIN32_FIND_DATAW *  fd, struct _wfinddata_t *  ft  )

static

Definition at line 81 of file dir.c.

{
  DWORD dw;
 
  if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
    ft->attrib = 0;
  else
    ft->attrib = fd->dwFileAttributes;
 
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw );
  ft->time_create = dw;
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
  ft->time_access = dw;
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
  ft->time_write = dw;
  ft->size = fd->nFileSizeLow;
  wcscpy(ft->name, fd->cFileName);
}

Referenced by _wfindfirst(), and _wfindnext().

msvcrt_wfttofd32()

static void msvcrt_wfttofd32 ( const WIN32_FIND_DATAW *  fd, struct _wfinddata32_t *  ft  )

static

Definition at line 101 of file dir.c.

{
  DWORD dw;
 
  if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
    ft->attrib = 0;
  else
    ft->attrib = fd->dwFileAttributes;
 
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw );
  ft->time_create = dw;
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
  ft->time_access = dw;
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
  ft->time_write = dw;
  ft->size = fd->nFileSizeLow;
  wcscpy(ft->name, fd->cFileName);
}

Referenced by _wfindfirst32(), and _wfindnext32().

msvcrt_wfttofd64()

static void msvcrt_wfttofd64 ( const WIN32_FIND_DATAW *  fd, struct _wfinddata64_t *  ft  )

static

Definition at line 141 of file dir.c.

{
  DWORD dw;
 
  if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
    ft->attrib = 0;
  else
    ft->attrib = fd->dwFileAttributes;
 
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw );
  ft->time_create = dw;
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
  ft->time_access = dw;
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
  ft->time_write = dw;
  ft->size = ((__int64)fd->nFileSizeHigh) << 32 | fd->nFileSizeLow;
  wcscpy(ft->name, fd->cFileName);
}

Referenced by _wfindfirst64(), and _wfindnext64().

msvcrt_wfttofd64i32()

static void msvcrt_wfttofd64i32 ( const WIN32_FIND_DATAW *  fd, struct _wfinddata64i32_t *  ft  )

static

Definition at line 181 of file dir.c.

{
  DWORD dw;
 
  if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
    ft->attrib = 0;
  else
    ft->attrib = fd->dwFileAttributes;
 
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw );
  ft->time_create = dw;
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
  ft->time_access = dw;
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
  ft->time_write = dw;
  ft->size = fd->nFileSizeLow;
  wcscpy(ft->name, fd->cFileName);
}

Referenced by _wfindfirst64i32(), and _wfindnext64i32().

msvcrt_wfttofdi64()

static void msvcrt_wfttofdi64 ( const WIN32_FIND_DATAW *  fd, struct _wfinddatai64_t *  ft  )

static

Definition at line 161 of file dir.c.

{
  DWORD dw;
 
  if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
    ft->attrib = 0;
  else
    ft->attrib = fd->dwFileAttributes;
 
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw );
  ft->time_create = dw;
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
  ft->time_access = dw;
  RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
  ft->time_write = dw;
  ft->size = ((__int64)fd->nFileSizeHigh) << 32 | fd->nFileSizeLow;
  wcscpy(ft->name, fd->cFileName);
}

Referenced by _wfindfirsti64(), and _wfindnexti64().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msvcrt

)