fseek.cpp File Reference

#include <corecrt_internal_stdio.h>
#include <corecrt_internal_ptd_propagation.h>
#include <intsafe.h>

Include dependency graph for fseek.cpp:

Go to the source code of this file.

Macros
#define	ENABLE_INTSAFE_SIGNED_FUNCTIONS

Functions
static bool __cdecl	common_fseek_binary_mode_read_only_fast_track_nolock (__crt_stdio_stream const stream, __int64 offset, int whence) throw ()
static int __cdecl	common_fseek_nolock (__crt_stdio_stream const stream, __int64 offset, int whence, __crt_cached_ptd_host &ptd) throw ()
static int __cdecl	common_fseek (__crt_stdio_stream const stream, __int64 const offset, int const whence, __crt_cached_ptd_host &ptd) throw ()
int __cdecl	fseek (FILE *const public_stream, long const offset, int const whence)
int __cdecl	_fseek_nolock (FILE *const public_stream, long const offset, int const whence)
int __cdecl	_fseeki64 (FILE *const public_stream, __int64 const offset, int const whence)
int __cdecl	_fseeki64_nolock (FILE *const public_stream, __int64 const offset, int const whence)

Macro Definition Documentation

ENABLE_INTSAFE_SIGNED_FUNCTIONS

#define ENABLE_INTSAFE_SIGNED_FUNCTIONS

Definition at line 12 of file fseek.cpp.

Function Documentation

_fseek_nolock()

int __cdecl _fseek_nolock	(	FILE *const	public_stream,
		long const	offset,
		int const	whence
	)

Definition at line 216 of file fseek.cpp.

{
    __crt_cached_ptd_host ptd;
    return common_fseek_nolock(__crt_stdio_stream(public_stream), offset, whence, ptd);
}

_fseeki64()

int __cdecl _fseeki64	(	FILE *const	public_stream,
		__int64 const	offset,
		int const	whence
	)

Definition at line 228 of file fseek.cpp.

{
    __crt_cached_ptd_host ptd;
    return common_fseek(__crt_stdio_stream(public_stream), offset, whence, ptd);
}

_fseeki64_nolock()

int __cdecl _fseeki64_nolock	(	FILE *const	public_stream,
		__int64 const	offset,
		int const	whence
	)

Definition at line 240 of file fseek.cpp.

{
    __crt_cached_ptd_host ptd;
    return common_fseek_nolock(__crt_stdio_stream(public_stream), offset, whence, ptd);
}

common_fseek()

static int __cdecl common_fseek ( __crt_stdio_stream const  stream, __int64 const  offset, int const  whence, __crt_cached_ptd_host &  ptd  ) throw ( )

static

Definition at line 176 of file fseek.cpp.

{
    _UCRT_VALIDATE_RETURN(ptd, stream.valid(), EINVAL, -1);
    _UCRT_VALIDATE_RETURN(ptd, whence == SEEK_SET || whence == SEEK_CUR || whence == SEEK_END, EINVAL, -1);
 
    int return_value = -1;
 
    _lock_file(stream.public_stream());
    __try
    {
        return_value = common_fseek_nolock(stream, offset, whence, ptd);
    }
    __finally
    {
        _unlock_file(stream.public_stream());
    }
    __endtry
 
    return return_value;
}

Referenced by _fseeki64(), and fseek().

common_fseek_binary_mode_read_only_fast_track_nolock()

static bool __cdecl common_fseek_binary_mode_read_only_fast_track_nolock ( __crt_stdio_stream const  stream, __int64  offset, int  whence  ) throw ( )

static

Definition at line 23 of file fseek.cpp.

{
    // This fast-track path does not handle the seek-from-end case (this is not
    // nearly as commonly used as seeking from the beginning or from the current
    // position).
    if (whence == SEEK_END)
    {
        return false;
    }
 
    // This fast-track path is only useful if the stream is buffered.
    if (!stream.has_any_buffer())
    {
        return false;
    }
 
    // This fast-track path requires a stream opened only for reading.  It may
    // be possible to handle streams opened for writing or update similarly;
    // further investigation would be required.
    if (stream.has_any_of(_IOWRITE | _IOUPDATE))
    {
        return false;
    }
 
    // The ftell function handles a case where _cnt is negative.  It isn't clear
    // why _cnt may be negative, so if _cnt is negative, fall back to the
    // expensive path.  If the _cnt is zero, do not assume that the buffer
    // contents contain the immediately preceding file content; data may have
    // been read from the file bypassing the buffer.  Fall back to the expensive
    // path to be sure.
    if (stream->_cnt <= 0)
    {
        return false;
    }
 
    // This fast-track path requires a binary mode file handle.  When text mode
    // or UTF transformations are enabled, the contents of the buffer do not
    // exactly match the contents of the underlying file.
    int const fh = stream.lowio_handle();
    if ((_osfile(fh) & FTEXT) != 0 || _textmode(fh) != __crt_lowio_text_mode::ansi)
    {
        return false;
    }
 
    // Handle the SEEK_SET case by transforming the SEEK_SET offset into a
    // SEEK_CUR offset:
    if (whence == SEEK_SET)
    {
        __int64 const lowio_position = _lseeki64_nolock(fh, 0, SEEK_CUR);
        if (lowio_position < 0)
        {
            return false;
        }
 
        __int64 const stdio_position = lowio_position - stream->_cnt;
        if (FAILED(LongLongSub(offset, stdio_position, &offset)))
        {
            return false;
        }
        whence = SEEK_CUR;
    }
 
    // Compute the maximum number of bytes that we can seek in each direction
    // within the buffer and verify that the requested offset is within that
    // range.  Note that the minimum reverse seek is a negative value.
    __int64 const minimum_reverse_seek = -(stream->_ptr - stream->_base);
    __int64 const maximum_forward_seek = stream->_cnt;
 
    bool const seek_is_within_buffer = minimum_reverse_seek <= offset && offset <= maximum_forward_seek;
    if (!seek_is_within_buffer)
    {
        return false;
    }
 
    stream->_ptr += offset;
 
    // Note that the cast here is safe:  The buffer will never be larger than
    // INT_MAX bytes in size.  The setvbuf function validates this constraint.
    stream->_cnt -= static_cast<int>(offset);
    return true;
}

Referenced by common_fseek_nolock().

common_fseek_nolock()

static int __cdecl common_fseek_nolock ( __crt_stdio_stream const  stream, __int64  offset, int  whence, __crt_cached_ptd_host &  ptd  ) throw ( )

static

Definition at line 111 of file fseek.cpp.

{
    if (!stream.is_in_use())
    {
        ptd.get_errno().set(EINVAL);
        return -1;
    }
 
    stream.unset_flags(_IOEOF);
 
    if (common_fseek_binary_mode_read_only_fast_track_nolock(stream, offset, whence))
    {
        return 0;
    }
 
    // If seeking relative to the current location, then convert to a seek
    // relative to the beginning of the file.  This accounts for buffering,
    // etc., by letting fseek() tell us where we are:
    if (whence == SEEK_CUR)
    {
        offset += _ftelli64_nolock_internal(stream.public_stream(), ptd);
        whence = SEEK_SET;
    }
 
    __acrt_stdio_flush_nolock(stream.public_stream(), ptd);
    // If the stream is opened in update mode and is currently in use for reading,
    // the buffer must be abandoned to ensure consistency when transitioning from
    // reading to writing.
    // __acrt_stdio_flush_nolock will not reset the buffer when _IOWRITE flag
    // is not set.
    __acrt_stdio_reset_buffer(stream);
 
    // If the file was opened for read/write, clear flags since we don't know
    // what the user will do next with the file.  If the file was opened for
    // read only access, decrease the _bufsiz so that the next call to
    // __acrt_stdio_refill_and_read_{narrow,wide}_nolock won't cost quite so
    // much:
    if (stream.has_all_of(_IOUPDATE))
    {
        stream.unset_flags(_IOWRITE | _IOREAD);
    }
    else if (stream.has_all_of(_IOREAD | _IOBUFFER_CRT) && !stream.has_any_of(_IOBUFFER_SETVBUF))
    {
        stream->_bufsiz = _SMALL_BUFSIZ;
    }
 
    if (_lseeki64_nolock_internal(stream.lowio_handle(), offset, whence, ptd) == -1)
    {
        return -1;
    }
 
    return 0;
}

Referenced by _fseek_nolock(), _fseeki64_nolock(), and common_fseek().

fseek()

int __cdecl fseek	(	FILE *const	public_stream,
		long const	offset,
		int const	whence
	)

Definition at line 204 of file fseek.cpp.

{
    __crt_cached_ptd_host ptd;
    return common_fseek(__crt_stdio_stream(public_stream), offset, whence, ptd);
}