corecrt_io.h File Reference

#include <corecrt_wio.h>
#include <pshpack8.h>
#include <poppack.h>

Include dependency graph for corecrt_io.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_finddata32_t
struct	_finddata32i64_t
struct	_finddata64i32_t
struct	_finddata64_t

Macros
#define	_finddata_t   _finddata64i32_t
#define	_finddatai64_t   _finddata64_t
#define	_A_NORMAL   0x00000000
#define	_A_RDONLY   0x00000001
#define	_A_HIDDEN   0x00000002
#define	_A_SYSTEM   0x00000004
#define	_A_VOLID   0x00000008
#define	_A_SUBDIR   0x00000010
#define	_A_ARCH   0x00000020
#define	_findfirst64i32   _findfirst
#define	_findfirst64   _findfirsti64
#define	_findnext64i32   _findnext
#define	_findnext64   _findnexti64

Functions
_ACRTIMP int __cdecl	_access (const char *, int)
_ACRTIMP int __cdecl	_chmod (const char *, int)
_ACRTIMP int __cdecl	_chsize (int, __msvcrt_long)
_ACRTIMP int __cdecl	_chsize_s (int, __int64)
_ACRTIMP int __cdecl	_close (int)
_ACRTIMP int __cdecl	_creat (const char *, int)
_ACRTIMP int __cdecl	_dup (int)
_ACRTIMP int __cdecl	_dup2 (int, int)
_ACRTIMP int __cdecl	_eof (int)
_ACRTIMP __int64 __cdecl	_filelengthi64 (int)
_ACRTIMP __msvcrt_long __cdecl	_filelength (int)
_ACRTIMP int __cdecl	_findclose (intptr_t)
_ACRTIMP intptr_t __cdecl	_findfirst (const char *, struct _finddata_t *)
_ACRTIMP intptr_t __cdecl	_findfirsti64 (const char *, struct _finddatai64_t *)
_ACRTIMP intptr_t __cdecl	_findfirst64 (const char *, struct _finddata64_t *)
_ACRTIMP int __cdecl	_findnext (intptr_t, struct _finddata_t *)
_ACRTIMP int __cdecl	_findnexti64 (intptr_t, struct _finddatai64_t *)
_ACRTIMP int __cdecl	_findnext64 (intptr_t, struct _finddata64_t *)
_ACRTIMP intptr_t __cdecl	_get_osfhandle (int)
_ACRTIMP int __cdecl	_isatty (int)
_ACRTIMP int __cdecl	_locking (int, int, __msvcrt_long)
_ACRTIMP __msvcrt_long __cdecl	_lseek (int, __msvcrt_long, int)
_ACRTIMP __int64 __cdecl	_lseeki64 (int, __int64, int)
_ACRTIMP char *__cdecl	_mktemp (char *)
_ACRTIMP int __cdecl	_mktemp_s (char *, size_t)
_ACRTIMP int __cdecl	_open (const char *, int,...)
_ACRTIMP int __cdecl	_open_osfhandle (intptr_t, int)
_ACRTIMP int __cdecl	_pipe (int *, unsigned int, int)
_ACRTIMP int __cdecl	_read (int, void *, unsigned int)
_ACRTIMP int __cdecl	_setmode (int, int)
_ACRTIMP int __cdecl	_sopen (const char *, int, int,...)
_ACRTIMP errno_t __cdecl	_sopen_dispatch (const char *, int, int, int, int *, int)
_ACRTIMP errno_t __cdecl	_sopen_s (int *, const char *, int, int, int)
_ACRTIMP __msvcrt_long __cdecl	_tell (int)
_ACRTIMP __int64 __cdecl	_telli64 (int)
_ACRTIMP int __cdecl	_umask (int)
_ACRTIMP int __cdecl	_unlink (const char *)
_ACRTIMP int __cdecl	_write (int, const void *, unsigned int)
_ACRTIMP int __cdecl	remove (const char *)
_ACRTIMP int __cdecl	rename (const char *, const char *)

Macro Definition Documentation

_A_ARCH

#define _A_ARCH   0x00000020

Definition at line 64 of file corecrt_io.h.

_A_HIDDEN

#define _A_HIDDEN   0x00000002

Definition at line 60 of file corecrt_io.h.

_A_NORMAL

#define _A_NORMAL   0x00000000

Definition at line 58 of file corecrt_io.h.

_A_RDONLY

#define _A_RDONLY   0x00000001

Definition at line 59 of file corecrt_io.h.

_A_SUBDIR

#define _A_SUBDIR   0x00000010

Definition at line 63 of file corecrt_io.h.

_A_SYSTEM

#define _A_SYSTEM   0x00000004

Definition at line 61 of file corecrt_io.h.

_A_VOLID

#define _A_VOLID   0x00000008

Definition at line 62 of file corecrt_io.h.

_finddata_t

#define _finddata_t   _finddata64i32_t

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

Definition at line 17 of file corecrt_io.h.

_finddatai64_t

#define _finddatai64_t   _finddata64_t

Definition at line 18 of file corecrt_io.h.

_findfirst64

#define _findfirst64   _findfirsti64

Definition at line 86 of file corecrt_io.h.

_findfirst64i32

#define _findfirst64i32   _findfirst

Definition at line 85 of file corecrt_io.h.

_findnext64

#define _findnext64   _findnexti64

Definition at line 88 of file corecrt_io.h.

_findnext64i32

#define _findnext64i32   _findnext

Definition at line 87 of file corecrt_io.h.

Function Documentation

_access()

_ACRTIMP int __cdecl _access	(	const char *	filename,
		int	mode
	)

Definition at line 990 of file file.c.

{
    wchar_t *filenameW = NULL;
    int ret;
 
    if (filename && !(filenameW = wstrdupa_utf8(filename))) return -1;
    ret = _waccess(filenameW, mode);
    free(filenameW);
    return ret;
}

Referenced by _access_s(), _searchenv_s(), access(), HaveSpool(), and MkDirs().

_chmod()

_ACRTIMP int __cdecl _chmod	(	const char *	path,
		int	flags
	)

Definition at line 1052 of file file.c.

{
    wchar_t *pathW = NULL;
    int ret;
 
    if (path && !(pathW = wstrdupa_utf8(path))) return -1;
    ret = _wchmod(pathW, flags);
    free(pathW);
    return ret;
}

Referenced by chmod(), LoadFirewallPrefs(), OpenBookmarkFile(), OpenTmpBookmarkFile(), OpenTrace(), rw(), SaveHistory(), test_file_write_read(), and test_utf8().

_chsize()

_ACRTIMP int __cdecl _chsize	(	int	fd,
		__msvcrt_long	size
	)

Definition at line 1663 of file file.c.

{
    /* _chsize_s returns errno on failure but _chsize should return -1 */
    return _chsize_s( fd, size ) == 0 ? 0 : -1;
}

Referenced by chsize(), ftruncate(), rw(), and test_chsize().

_chsize_s()

_ACRTIMP int __cdecl _chsize_s	(	int	fd,
		__int64	size
	)

Definition at line 1626 of file file.c.

{
    ioinfo *info;
    __int64 cur, pos;
    BOOL ret = FALSE;
 
    TRACE("(fd=%d, size=%#I64x)\n", fd, size);
 
    if (!MSVCRT_CHECK_PMT(size >= 0)) return EINVAL;
 
 
    info = get_ioinfo(fd);
    if (info->handle != INVALID_HANDLE_VALUE)
    {
        /* save the current file pointer */
        cur = _lseeki64(fd, 0, SEEK_CUR);
        if (cur >= 0)
        {
            pos = _lseeki64(fd, size, SEEK_SET);
            if (pos >= 0)
            {
                ret = SetEndOfFile(info->handle);
                if (!ret) msvcrt_set_errno(GetLastError());
            }
 
            /* restore the file pointer */
            _lseeki64(fd, cur, SEEK_SET);
        }
    }
 
    release_ioinfo(info);
    return ret ? 0 : *_errno();
}

Referenced by _chsize().

_close()

_ACRTIMP int __cdecl _close

(

int

fd

)

Definition at line 1219 of file file.c.

{
  ioinfo *info = get_ioinfo(fd);
  int ret;
 
  TRACE(":fd (%d) handle (%p)\n", fd, info->handle);
 
  if (fd == MSVCRT_NO_CONSOLE_FD) {
    *_errno() = EBADF;
    ret = -1;
  } else if (!MSVCRT_CHECK_PMT_ERR(info->wxflag & WX_OPEN, EBADF)) {
    ret = -1;
  } else if (fd == STDOUT_FILENO &&
          info->handle == get_ioinfo_nolock(STDERR_FILENO)->handle) {
    msvcrt_free_fd(fd);
    ret = 0;
  } else if (fd == STDERR_FILENO &&
          info->handle == get_ioinfo_nolock(STDOUT_FILENO)->handle) {
    msvcrt_free_fd(fd);
    ret = 0;
  } else {
    ret = CloseHandle(info->handle) ? 0 : -1;
    msvcrt_free_fd(fd);
    if (ret) {
      WARN(":failed-last error (%ld)\n", GetLastError());
      msvcrt_set_errno(GetLastError());
    }
  }
  release_ioinfo(info);
  return ret;
}

Referenced by _dup2(), _fclose_nolock(), _pipe(), _Success_(), _tutime(), _utime64(), _wfsopen(), _wpopen(), _wutime64(), anonymous_namespace{stat.cpp}::file_handle_traits::close(), close(), common_popen(), common_popen_nolock(), common_utime(), compat_close(), fclose(), install_from_unix_file(), main(), rd_close_file(), run_open_osfhandle(), rw(), test__creat(), test__popen(), test__sopen_dispatch(), test__sopen_s(), test_chsize(), test_file_write_read(), test_get_osfhandle(), test_lseek(), test_setmode(), and tmpfile().

_creat()

_ACRTIMP int __cdecl _creat	(	const char *	path,
		int	pmode
	)

Definition at line 2693 of file file.c.

{
  int flags = _O_CREAT | _O_TRUNC | _O_RDWR;
  return _open(path, flags, pmode);
}

Referenced by creat(), test__creat(), and test_lseek().

_dup()

_ACRTIMP int __cdecl _dup

(

int

od

)

Definition at line 1317 of file file.c.

{
  int fd, ret;
  ioinfo *info = get_ioinfo_alloc(&fd);
 
  if (_dup2(od, fd) == 0)
    ret = fd;
  else
    ret = -1;
  release_ioinfo(info);
  return ret;
}

Referenced by _wpopen(), DllMain(), dup(), test_std_stream_buffering(), test_std_stream_open(), and test_stdin().

_dup2()

_ACRTIMP int __cdecl _dup2	(	int	od,
		int	nd
	)

Definition at line 1258 of file file.c.

{
  ioinfo *info_od, *info_nd;
  int ret;
 
  TRACE("(od=%d, nd=%d)\n", od, nd);
 
  if (od < nd)
  {
    info_od = get_ioinfo(od);
    info_nd = get_ioinfo_alloc_fd(nd);
  }
  else
  {
    info_nd = get_ioinfo_alloc_fd(nd);
    info_od = get_ioinfo(od);
  }
 
  if (info_nd == &MSVCRT___badioinfo)
  {
      *_errno() = EBADF;
      ret = -1;
  }
  else if (info_od->wxflag & WX_OPEN)
  {
    HANDLE handle;
 
    if (DuplicateHandle(GetCurrentProcess(), info_od->handle,
     GetCurrentProcess(), &handle, 0, TRUE, DUPLICATE_SAME_ACCESS))
    {
      int wxflag = info_od->wxflag & ~WX_DONTINHERIT;
 
      if (info_nd->wxflag & WX_OPEN)
        _close(nd);
 
      msvcrt_set_fd(info_nd, handle, wxflag);
      /* _dup2 returns 0, not nd, on success */
      ret = 0;
    }
    else
    {
      ret = -1;
      msvcrt_set_errno(GetLastError());
    }
  }
  else
  {
    *_errno() = EBADF;
    ret = -1;
  }
 
  release_ioinfo(info_od);
  release_ioinfo(info_nd);
  return ret;
}

Referenced by _dup(), _tWinMain(), DllMain(), dup2(), test_dup2(), test_stat(), test_std_stream_buffering(), test_std_stream_open(), and test_stdin().

_eof()

_ACRTIMP int __cdecl _eof

(

int

fd

)

Definition at line 1333 of file file.c.

{
  ioinfo *info = get_ioinfo(fd);
  DWORD curpos,endpos;
  LONG hcurpos,hendpos;
 
  TRACE(":fd (%d) handle (%p)\n", fd, info->handle);
 
  if (info->handle == INVALID_HANDLE_VALUE)
  {
    release_ioinfo(info);
    return -1;
  }
 
  if (info->wxflag & WX_ATEOF)
  {
      release_ioinfo(info);
      return TRUE;
  }
 
  /* Otherwise we do it the hard way */
  hcurpos = hendpos = 0;
  curpos = SetFilePointer(info->handle, 0, &hcurpos, FILE_CURRENT);
  endpos = SetFilePointer(info->handle, 0, &hendpos, FILE_END);
 
  if (curpos == endpos && hcurpos == hendpos)
  {
    /* FIXME: shouldn't WX_ATEOF be set here? */
    release_ioinfo(info);
    return TRUE;
  }
 
  SetFilePointer(info->handle, curpos, &hcurpos, FILE_BEGIN);
  release_ioinfo(info);
  return FALSE;
}

Referenced by eof().

_filelength()

_ACRTIMP __msvcrt_long __cdecl _filelength

(

int

fd

)

Definition at line 1887 of file file.c.

{
  LONG curPos = _lseek(fd, 0, SEEK_CUR);
  if (curPos != -1)
  {
    LONG endPos = _lseek(fd, 0, SEEK_END);
    if (endPos != -1)
    {
      if (endPos != curPos)
        _lseek(fd, curPos, SEEK_SET);
      return endPos;
    }
  }
  return -1;
}

Referenced by filelength(), File::length(), and test_chsize().

_filelengthi64()

_ACRTIMP __int64 __cdecl _filelengthi64

(

int

fd

)

Definition at line 1906 of file file.c.

{
  __int64 curPos = _lseeki64(fd, 0, SEEK_CUR);
  if (curPos != -1)
  {
    __int64 endPos = _lseeki64(fd, 0, SEEK_END);
    if (endPos != -1)
    {
      if (endPos != curPos)
        _lseeki64(fd, curPos, SEEK_SET);
      return endPos;
    }
  }
  return -1;
}

_findclose()

_ACRTIMP 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()

_ACRTIMP 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;
}

_findfirst64()

_ACRTIMP 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;
}

_findfirsti64()

_ACRTIMP 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()

_ACRTIMP 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;
}

_findnext64()

_ACRTIMP 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;
}

_findnexti64()

_ACRTIMP 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;
}

_get_osfhandle()

_ACRTIMP intptr_t __cdecl _get_osfhandle

(

int

fd

)

Definition at line 2117 of file file.c.

{
  HANDLE hand = get_ioinfo_nolock(fd)->handle;
  TRACE(":fd (%d) handle (%p)\n",fd,hand);
 
  if(hand == INVALID_HANDLE_VALUE)
      *_errno() = EBADF;
  return (intptr_t)hand;
}

Referenced by _chsize_nolock_internal(), _commit(), _dup2_nolock_internal(), _getch(), _wpopen(), close_os_handle_nolock(), common_futime(), common_lseek_nolock(), ConStreamGetOSHandle(), do_spawnT(), duplicate_osfhnd(), fork_helper(), has_sequential_hint(), locking_nolock(), stream_is_at_end_of_file_nolock(), test__popen_child(), test_close(), test_get_osfhandle(), test_invalid_stdin_child(), test_ioinfo_flags(), and test_stdin().

_isatty()

_ACRTIMP int __cdecl _isatty

(

int

fd

)

Definition at line 858 of file file.c.

{
    TRACE(":fd (%d)\n",fd);
 
    return get_ioinfo_nolock(fd)->wxflag & WX_TTY;
}

Referenced by __acrt_should_use_temporary_buffer(), _read_nolock(), _write(), add_std_buffer(), GetPass(), gl_init(), isatty(), msvcrt_alloc_buffer(), and write_requires_double_translation_nolock().

_locking()

_ACRTIMP int __cdecl _locking	(	int	fd,
		int	mode,
		__msvcrt_long	nbytes
	)

Definition at line 1513 of file file.c.

{
  ioinfo *info = get_ioinfo(fd);
  BOOL ret;
  DWORD cur_locn;
 
  TRACE(":fd (%d) handle (%p)\n", fd, info->handle);
  if (info->handle == INVALID_HANDLE_VALUE)
  {
    release_ioinfo(info);
    return -1;
  }
 
  if (mode < 0 || mode > 4)
  {
    release_ioinfo(info);
    *_errno() = EINVAL;
    return -1;
  }
 
  TRACE(":fd (%d) by %#lx mode %s\n",
          fd, nbytes, (mode == _LK_UNLCK) ? "_LK_UNLCK" :
          (mode == _LK_LOCK) ? "_LK_LOCK" :
          (mode == _LK_NBLCK) ? "_LK_NBLCK" :
          (mode == _LK_RLCK) ? "_LK_RLCK" :
          (mode == _LK_NBRLCK) ? "_LK_NBRLCK" :
          "UNKNOWN");
 
  if ((cur_locn = SetFilePointer(info->handle, 0L, NULL, FILE_CURRENT)) == INVALID_SET_FILE_POINTER)
  {
    release_ioinfo(info);
    FIXME("Seek failed\n");
    *_errno() = EINVAL; /* FIXME */
    return -1;
  }
  if (mode == _LK_LOCK || mode == _LK_RLCK)
  {
    int nretry = 10;
    ret = 1; /* just to satisfy gcc */
    while (nretry--)
    {
      ret = LockFile(info->handle, cur_locn, 0L, nbytes, 0L);
      if (ret) break;
      Sleep(1);
    }
  }
  else if (mode == _LK_UNLCK)
    ret = UnlockFile(info->handle, cur_locn, 0L, nbytes, 0L);
  else
    ret = LockFile(info->handle, cur_locn, 0L, nbytes, 0L);
  /* FIXME - what about error settings? */
  release_ioinfo(info);
  return ret ? 0 : -1;
}

Referenced by locking().

_lseek()

_ACRTIMP __msvcrt_long __cdecl _lseek	(	int	fd,
		__msvcrt_long	offset,
		int	whence
	)

Definition at line 1479 of file file.c.

{
    return _lseeki64(fd, offset, whence);
}

Referenced by _filelength(), _tell(), _write(), lseek(), rd_lseek_file(), rw(), test__creat(), test_chsize(), test_fflush(), test_file_write_read(), and test_lseek().

_lseeki64()

_ACRTIMP __int64 __cdecl _lseeki64	(	int	fd,
		__int64	offset,
		int	whence
	)

Definition at line 1432 of file file.c.

{
  ioinfo *info = get_ioinfo(fd);
  LARGE_INTEGER ofs;
 
  TRACE(":fd (%d) handle (%p)\n", fd, info->handle);
 
  if (info->handle == INVALID_HANDLE_VALUE)
  {
    *_errno() = EBADF;
    release_ioinfo(info);
    return -1;
  }
 
  if (whence < 0 || whence > 2)
  {
    release_ioinfo(info);
    *_errno() = EINVAL;
    return -1;
  }
 
  TRACE(":fd (%d) to %#I64x pos %s\n",
          fd, offset, (whence == SEEK_SET) ? "SEEK_SET" :
          (whence == SEEK_CUR) ? "SEEK_CUR" :
          (whence == SEEK_END) ? "SEEK_END" : "UNKNOWN");
 
  /* The MoleBox protection scheme expects msvcrt to use SetFilePointer only,
   * so a LARGE_INTEGER offset cannot be passed directly via SetFilePointerEx. */
  ofs.QuadPart = offset;
  if ((ofs.u.LowPart = SetFilePointer(info->handle, ofs.u.LowPart, &ofs.u.HighPart, whence)) != INVALID_SET_FILE_POINTER ||
      GetLastError() == ERROR_SUCCESS)
  {
    info->wxflag &= ~WX_ATEOF;
    /* FIXME: What if we seek _to_ EOF - is EOF set? */
 
    release_ioinfo(info);
    return ofs.QuadPart;
  }
  release_ioinfo(info);
  TRACE(":error-last error (%ld)\n", GetLastError());
  msvcrt_set_errno(GetLastError());
  return -1;
}

Referenced by _chsize_s(), _filelengthi64(), _fseeki64(), _fseeki64_nolock(), _ftelli64(), _ftelli64_nolock(), _lseek(), _telli64(), fsetpos(), and write_buffer_nolock().

_mktemp()

_ACRTIMP char *__cdecl _mktemp

(

char *

pattern

)

Definition at line 2176 of file file.c.

{
  wchar_t *pathW, *p;
  int numX = 0;
  char *retVal = pattern;
  int id;
  char letter = 'a';
 
  if(!pattern)
      return NULL;
 
  while(*pattern)
    numX = (*pattern++ == 'X')? numX + 1 : 0;
  if (numX < 6)
    return NULL;
  pattern--;
  id = GetCurrentProcessId();
  numX = 6;
  while(numX--)
  {
    int tempNum = id / 10;
    *pattern-- = id - (tempNum * 10) + '0';
    id = tempNum;
  }
  pattern++;
  if (!(pathW = wstrdupa_utf8(retVal)))
    return NULL;
  p = pathW + wcslen(pathW) - 6;
  do
  {
    *p = letter++;
    if (GetFileAttributesW(pathW) == INVALID_FILE_ATTRIBUTES)
    {
      *pattern = *p;
      free(pathW);
      return retVal;
    }
  } while(letter <= 'z');
  free(pathW);
  return NULL;
}

Referenced by mktemp(), test_mktemp(), and test_utf8().

_mktemp_s()

_ACRTIMP int __cdecl _mktemp_s	(	char *	pattern,
		size_t	size
	)

Definition at line 2130 of file file.c.

{
    DWORD len, wlen, xno, id;
    wchar_t *pathW;
 
    if(!MSVCRT_CHECK_PMT(pattern!=NULL))
        return EINVAL;
 
    for(len=0; len<size; len++)
        if(!pattern[len])
            break;
    if(!MSVCRT_CHECK_PMT(len!=size && len>=6)) {
        if(size)
            pattern[0] = 0;
        return EINVAL;
    }
 
    for(xno=1; xno<=6; xno++)
        if(!MSVCRT_CHECK_PMT(pattern[len-xno] == 'X'))
            return EINVAL;
 
    id = GetCurrentProcessId();
    for(xno=1; xno<6; xno++) {
        pattern[len-xno] = id%10 + '0';
        id /= 10;
    }
 
    if(!(pathW = wstrdupa_utf8(pattern))) return *_errno();
    wlen = wcslen(pathW);
    for(pathW[wlen-6]='a'; pathW[wlen-6]<='z'; pathW[wlen-6]++) {
        if(GetFileAttributesW(pathW) == INVALID_FILE_ATTRIBUTES) {
            pattern[len-6] = pathW[wlen-6];
            free(pathW);
            return 0;
        }
    }
    free(pathW);
 
    pattern[0] = 0;
    *_errno() = EEXIST;
    return EEXIST;
}

Referenced by test_utf8().

_open()

_ACRTIMP int __cdecl _open	(	const char *	path,
		int	flags,
			...
	)

Definition at line 2655 of file file.c.

{
  va_list ap;
 
  if (flags & _O_CREAT)
  {
    int pmode;
    va_start(ap, flags);
    pmode = va_arg(ap, int);
    va_end(ap);
    return _sopen( path, flags, _SH_DENYNO, pmode );
  }
  else
    return _sopen( path, flags, _SH_DENYNO);
}

_open_osfhandle()

_ACRTIMP int __cdecl _open_osfhandle	(	intptr_t	handle,
		int	oflags
	)

Definition at line 2711 of file file.c.

{
  DWORD flags;
  int fd;
 
  /* _O_RDONLY (0) always matches, so set the read flag
   * MFC's CStdioFile clears O_RDONLY (0)! if it wants to write to the
   * file, so set the write flag. It also only sets _O_TEXT if it wants
   * text - it never sets _O_BINARY.
   */
  /* don't let split_oflags() decide the mode if no mode is passed */
  if (!(oflags & (_O_BINARY | _O_TEXT)))
      oflags |= _O_BINARY;
 
  flags = GetFileType((HANDLE)handle);
  if (flags==FILE_TYPE_UNKNOWN && GetLastError()!=NO_ERROR)
  {
    msvcrt_set_errno(GetLastError());
    return -1;
  }
 
  if (flags == FILE_TYPE_CHAR)
    flags = WX_TTY;
  else if (flags == FILE_TYPE_PIPE)
    flags = WX_PIPE;
  else
    flags = 0;
  flags |= split_oflags(oflags);
 
  fd = msvcrt_alloc_fd((HANDLE)handle, flags);
  TRACE(":handle (%Iu) fd (%d) flags %#lx\n", handle, fd, flags);
  return fd;
}

Referenced by _tWinMain(), ConStreamSetOSHandle(), run_open_osfhandle(), test__open_osfhandle(), and test_close().

_pipe()

_ACRTIMP int __cdecl _pipe	(	int *	pfds,
		unsigned int	psize,
		int	textmode
	)

Definition at line 2323 of file file.c.

{
  int ret = -1;
  SECURITY_ATTRIBUTES sa;
  HANDLE readHandle, writeHandle;
 
  if (!pfds)
  {
    *_errno() = EINVAL;
    return -1;
  }
 
  sa.nLength = sizeof(SECURITY_ATTRIBUTES);
  sa.bInheritHandle = !(textmode & _O_NOINHERIT);
  sa.lpSecurityDescriptor = NULL;
  if (CreatePipe(&readHandle, &writeHandle, &sa, psize))
  {
    unsigned int wxflags = split_oflags(textmode);
    int fd;
 
    fd = msvcrt_alloc_fd(readHandle, wxflags|WX_PIPE);
    if (fd != -1)
    {
      pfds[0] = fd;
      fd = msvcrt_alloc_fd(writeHandle, wxflags|WX_PIPE);
      if (fd != -1)
      {
        pfds[1] = fd;
        ret = 0;
      }
      else
      {
        _close(pfds[0]);
        CloseHandle(writeHandle);
        *_errno() = EMFILE;
      }
    }
    else
    {
      CloseHandle(readHandle);
      CloseHandle(writeHandle);
      *_errno() = EMFILE;
    }
  }
  else
    msvcrt_set_errno(GetLastError());
 
  return ret;
}

Referenced by _wpopen(), common_popen(), fork_helper(), test_file_inherit(), test_pipes(), and test_stat().

_read()

_ACRTIMP int __cdecl _read	(	int	fd,
		void *	buf,
		unsigned int	count
	)

Definition at line 3127 of file file.c.

{
    ioinfo *info;
    int num_read;
 
    if(fd == MSVCRT_NO_CONSOLE_FD) {
        *_errno() = EBADF;
        return -1;
    }
 
    info = get_ioinfo(fd);
    num_read = read_i(fd, info, buf, count);
    release_ioinfo(info);
    return num_read;
}

Referenced by _filbuf(), _fread_nolock(), common_refill_and_read_nolock(), fread(), rd_read_file(), read(), read_pipe_thread(), rw(), test__creat(), and test_file_write_read().

_setmode()

_ACRTIMP int __cdecl _setmode	(	int	fd,
		int	mode
	)

Definition at line 3146 of file file.c.

{
    ioinfo *info = get_ioinfo(fd);
    int ret = info->wxflag & WX_TEXT ? _O_TEXT : _O_BINARY;
 
    if(ret==_O_TEXT && ioinfo_get_textmode(info) != TEXTMODE_ANSI)
        ret = _O_WTEXT;
 
    if(mode!=_O_TEXT && mode!=_O_BINARY && mode!=_O_WTEXT
                && mode!=_O_U16TEXT && mode!=_O_U8TEXT) {
        *_errno() = EINVAL;
        release_ioinfo(info);
        return -1;
    }
 
    if(info == &MSVCRT___badioinfo) {
        *_errno() = EBADF;
        return EOF;
    }
 
    if(mode == _O_BINARY) {
        info->wxflag &= ~WX_TEXT;
        ioinfo_set_textmode(info, TEXTMODE_ANSI);
        release_ioinfo(info);
        return ret;
    }
 
    info->wxflag |= WX_TEXT;
    if(mode == _O_TEXT)
        ioinfo_set_textmode(info, TEXTMODE_ANSI);
    else if(mode == _O_U8TEXT)
        ioinfo_set_textmode(info, TEXTMODE_UTF8);
    else
        ioinfo_set_textmode(info, TEXTMODE_UTF16LE);
 
    release_ioinfo(info);
    return ret;
}

_sopen()

_ACRTIMP int __cdecl _sopen	(	const char *	path,
		int	oflags,
		int	shflags,
			...
	)

Definition at line 2633 of file file.c.

{
  int pmode;
  int fd;
 
  if (oflags & _O_CREAT)
  {
    va_list ap;
 
    va_start(ap, shflags);
    pmode = va_arg(ap, int);
    va_end(ap);
  }
  else
    pmode = 0;
 
  return _sopen_dispatch(path, oflags, shflags, pmode, &fd, 0) ? -1 : fd;
}

_sopen_dispatch()

_ACRTIMP errno_t __cdecl _sopen_dispatch	(	const char *	path,
		int	oflags,
		int	shflags,
		int	pmode,
		int *	fd,
		int	secure
	)

Definition at line 2606 of file file.c.

{
    wchar_t *pathW = NULL;
    int ret;
 
    if (!MSVCRT_CHECK_PMT(fd != NULL))
        return EINVAL;
    *fd = -1;
    if (path && !(pathW = wstrdupa_utf8(path))) return *_errno();
 
    ret = _wsopen_dispatch(pathW, oflags, shflags, pmode, fd, secure);
    free(pathW);
    return ret;
}

Referenced by _sopen(), _sopen_s(), and test__sopen_dispatch().

_sopen_s()

_ACRTIMP errno_t __cdecl _sopen_s	(	int *	fd,
		const char *	path,
		int	oflags,
		int	shflags,
		int	pmode
	)

Definition at line 2625 of file file.c.

{
    return _sopen_dispatch(path, oflags, shflags, pmode, fd, 1);
}

Referenced by _sopen(), _Success_(), and test__sopen_s().

_tell()

_ACRTIMP __msvcrt_long __cdecl _tell

(

int

fd

)

Definition at line 3425 of file file.c.

{
  return _lseek(fd, 0, SEEK_CUR);
}

Referenced by tell(), and test__creat().

_telli64()

_ACRTIMP __int64 __cdecl _telli64

(

int

fd

)

Definition at line 3433 of file file.c.

{
  return _lseeki64(fd, 0, SEEK_CUR);
}

Referenced by _ftelli64(), _ftelli64_nolock(), and test_std_stream_buffering().

_umask()

_ACRTIMP int __cdecl _umask

(

int

umask

)

Definition at line 3486 of file file.c.

{
  int old_umask = MSVCRT_umask;
  TRACE("(%d)\n",umask);
  MSVCRT_umask = umask;
  return old_umask;
}

_unlink()

_ACRTIMP int __cdecl _unlink

(

const char *

path

)

Definition at line 1085 of file file.c.

{
    wchar_t *pathW = NULL;
    int ret;
 
    if (path && !(pathW = wstrdupa_utf8(path))) return -1;
    ret = _wunlink(pathW);
    free(pathW);
    return ret;
}

_write()

_ACRTIMP int __cdecl _write	(	int	fd,
		const void *	buf,
		unsigned int	count
	)

Definition at line 3561 of file file.c.

{
    ioinfo *info = get_ioinfo(fd);
    HANDLE hand = info->handle;
    DWORD num_written, i;
    BOOL console = FALSE;
 
    if (hand == INVALID_HANDLE_VALUE || fd == MSVCRT_NO_CONSOLE_FD)
    {
        *_errno() = EBADF;
        release_ioinfo(info);
        return -1;
    }
 
    if (ioinfo_get_textmode(info) != TEXTMODE_ANSI && count&1)
    {
        *_errno() = EINVAL;
        release_ioinfo(info);
        return -1;
    }
 
    /* If appending, go to EOF */
    if (info->wxflag & WX_APPEND)
        _lseek(fd, 0, FILE_END);
 
    if (!(info->wxflag & WX_TEXT))
    {
        if (!WriteFile(hand, buf, count, &num_written, NULL)
                ||  num_written != count)
        {
            TRACE("WriteFile (fd %d, hand %p) failed-last error (%ld)\n", fd,
                    hand, GetLastError());
            msvcrt_set_errno(GetLastError());
            if (GetLastError() == ERROR_ACCESS_DENIED)
                *_errno() = EBADF;
            num_written = -1;
        }
 
        release_ioinfo(info);
        return num_written;
    }
 
    if (_isatty(fd)) console = VerifyConsoleIoHandle(hand);
    for (i = 0; i < count;)
    {
        const char *s = buf;
        char lfbuf[2048];
        DWORD j = 0;
 
        if (ioinfo_get_textmode(info) == TEXTMODE_ANSI && console)
        {
            char conv[sizeof(lfbuf)];
            size_t len = 0;
 
#if _MSVCR_VER >= 80
            if (info->dbcsBufferUsed)
            {
                conv[j++] = info->dbcsBuffer[0];
                info->dbcsBufferUsed = FALSE;
                conv[j++] = s[i++];
                len++;
            }
#endif
 
            for (; i < count && j < sizeof(conv)-1 &&
                    len < (sizeof(lfbuf) - 1) / sizeof(WCHAR); i++, j++, len++)
            {
                if (isleadbyte((unsigned char)s[i]))
                {
                    conv[j++] = s[i++];
 
                    if (i == count)
                    {
#if _MSVCR_VER >= 80
                        info->dbcsBuffer[0] = conv[j-1];
                        info->dbcsBufferUsed = TRUE;
                        break;
#else
                        *_errno() = EINVAL;
                        release_ioinfo(info);
                        return -1;
#endif
                    }
                }
                else if (s[i] == '\n')
                {
                    conv[j++] = '\r';
                    len++;
                }
                conv[j] = s[i];
            }
 
            len = mbstowcs((WCHAR*)lfbuf, conv, len);
            if (len == -1)
            {
                msvcrt_set_errno(GetLastError());
                release_ioinfo(info);
                return -1;
            }
            j = len * 2;
        }
        else if (ioinfo_get_textmode(info) == TEXTMODE_ANSI)
        {
            for (j = 0; i < count && j < sizeof(lfbuf)-1; i++, j++)
            {
                if (s[i] == '\n')
                    lfbuf[j++] = '\r';
                lfbuf[j] = s[i];
            }
        }
        else if (ioinfo_get_textmode(info) == TEXTMODE_UTF16LE || console)
        {
            for (j = 0; i < count && j < sizeof(lfbuf)-3; i++, j++)
            {
                if (s[i] == '\n' && !s[i+1])
                {
                    lfbuf[j++] = '\r';
                    lfbuf[j++] = 0;
                }
                lfbuf[j++] = s[i++];
                lfbuf[j] = s[i];
            }
        }
        else
        {
            char conv[sizeof(lfbuf)/4];
 
            for (j = 0; i < count && j < sizeof(conv)-3; i++, j++)
            {
                if (s[i] == '\n' && !s[i+1])
                {
                    conv[j++] = '\r';
                    conv[j++] = 0;
                }
                conv[j++] = s[i++];
                conv[j] = s[i];
            }
 
            j = WideCharToMultiByte(CP_UTF8, 0, (WCHAR*)conv, j/2, lfbuf, sizeof(lfbuf), NULL, NULL);
            if (!j)
            {
                msvcrt_set_errno(GetLastError());
                release_ioinfo(info);
                return -1;
            }
        }
 
        if (console)
        {
            j = j/2;
            if (!WriteConsoleW(hand, lfbuf, j, &num_written, NULL))
                num_written = -1;
        }
        else if (!WriteFile(hand, lfbuf, j, &num_written, NULL))
        {
            num_written = -1;
        }
 
        if (num_written != j)
        {
            TRACE("WriteFile/WriteConsoleW (fd %d, hand %p) failed-last error (%ld)\n", fd,
                    hand, GetLastError());
            msvcrt_set_errno(GetLastError());
            if (GetLastError() == ERROR_ACCESS_DENIED)
                *_errno() = EBADF;
            release_ioinfo(info);
            return -1;
        }
    }
 
    release_ioinfo(info);
    return count;
}

Referenced by _flsbuf(), _fwrite_nolock(), _putw(), configure_text_mode(), fwrite(), msvcrt_flush_buffer(), perror(), rd_write_file(), rw(), test__creat(), test_chsize(), test_file_inherit(), test_file_write_read(), test_lseek(), and write().

remove()

_ACRTIMP int __cdecl remove

(

const char *

path

)

Definition at line 4957 of file file.c.

{
    return _unlink(path);
}

rename()

_ACRTIMP int __cdecl rename	(	const char *	oldpath,
		const char *	newpath
	)

Definition at line 4973 of file file.c.

{
    wchar_t *oldpathW = NULL, *newpathW = NULL;
    int ret;
 
    if (oldpath && !(oldpathW = wstrdupa_utf8(oldpath))) return -1;
    if (newpath && !(newpathW = wstrdupa_utf8(newpath)))
    {
        free(oldpathW);
        return -1;
    }
    ret = _wrename(oldpathW, newpathW);
    free(oldpathW);
    free(newpathW);
    return ret;
}