/* define locking/validating lseek */
long __cdecl _lseek (
int fh,
long pos,
int mthd
)
{
int r;
/* validate fh */
_CHECK_FH_CLEAR_OSSERR_RETURN( fh, EBADF, -1 );
_VALIDATE_CLEAR_OSSERR_RETURN((fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, -1);
_VALIDATE_CLEAR_OSSERR_RETURN((_osfile(fh) & FOPEN), EBADF, -1);
_lock_fh(fh); /* lock file handle */
__try {
if ( _osfile(fh) & FOPEN )
r = _lseek_nolock(fh, pos, mthd); /* seek */
else {
errno = EBADF;
_doserrno = 0;
r = -1;
_ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
}
}
__finally {
_unlock_fh(fh); /* unlock file handle */
}
return r;
}
int __cdecl _dup (
int fh
)
{
int newfh =-1; /* variable for new file handle */
/* validate file handle */
_CHECK_FH_CLEAR_OSSERR_RETURN( fh, EBADF, -1 );
_VALIDATE_CLEAR_OSSERR_RETURN((fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, -1);
_VALIDATE_CLEAR_OSSERR_RETURN((_osfile(fh) & FOPEN), EBADF, -1);
_lock_fh(fh); /* lock file handle */
__TRY
if ( _osfile(fh) & FOPEN )
newfh = _dup_nolock(fh);
else {
errno = EBADF;
_doserrno = 0;
newfh = -1;
_ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
}
__FINALLY
_unlock_fh(fh);
__END_TRY_FINALLY
return newfh;
}
// Locks or unlocks the requested number of bytes in the specified file.
//
// Note that this function acquires the lock for the specified file and holds
// this lock for the entire duration of the call, even during the one second
// delays between calls into the operating system. This is to prevent other
// threads from changing the file during the call.
//
// Returns 0 on success; returns -1 and sets errno on failure.
extern "C" int __cdecl _locking(int const fh, int const locking_mode, long const number_of_bytes)
{
_CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1);
_VALIDATE_CLEAR_OSSERR_RETURN(fh >= 0 && (unsigned)fh < (unsigned)_nhandle, EBADF, -1);
_VALIDATE_CLEAR_OSSERR_RETURN(_osfile(fh) & FOPEN, EBADF, -1);
_VALIDATE_CLEAR_OSSERR_RETURN(number_of_bytes >= 0, EINVAL, -1);
__acrt_lowio_lock_fh(fh);
int result = -1;
__try
{
if ((_osfile(fh) & FOPEN) == 0)
{
errno = EBADF;
_doserrno = 0;
_ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
__leave;
}
result = locking_nolock(fh, locking_mode, number_of_bytes);
}
__finally
{
__acrt_lowio_unlock_fh(fh);
}
return result;
}
/* define normal version that locks/unlocks, validates fh */
int __cdecl _read (
int fh,
void *buf,
unsigned cnt
)
{
int r; /* return value */
/* validate handle */
_CHECK_FH_CLEAR_OSSERR_RETURN( fh, EBADF, -1 );
_VALIDATE_CLEAR_OSSERR_RETURN((fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, -1);
_VALIDATE_CLEAR_OSSERR_RETURN((_osfile(fh) & FOPEN), EBADF, -1);
_lock_fh(fh); /* lock file */
__try {
if ( _osfile(fh) & FOPEN )
r = _read_nolock(fh, buf, cnt); /* read bytes */
else {
errno = EBADF;
_doserrno = 0;
r = -1;
_ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
}
}
__finally {
_unlock_fh(fh); /* unlock file */
}
return r;
}
static Integer __cdecl common_lseek(int const fh, Integer const offset, int const origin) throw()
{
_CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1);
_VALIDATE_CLEAR_OSSERR_RETURN(fh >= 0 && (unsigned)fh < (unsigned)_nhandle, EBADF, -1);
_VALIDATE_CLEAR_OSSERR_RETURN(_osfile(fh) & FOPEN, EBADF, -1);
__acrt_lowio_lock_fh(fh);
Integer result = -1;
__try
{
if ((_osfile(fh) & FOPEN) == 0)
{
errno = EBADF;
_doserrno = 0;
_ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
__leave;
}
result = common_lseek_nolock(fh, offset, origin);
}
__finally
{
__acrt_lowio_unlock_fh(fh);
}
return result;
}
int __cdecl _eof (
int filedes
)
{
__int64 here;
__int64 end;
int retval;
_CHECK_FH_CLEAR_OSSERR_RETURN( filedes, EBADF, -1 );
_VALIDATE_CLEAR_OSSERR_RETURN((filedes >= 0 && (unsigned)filedes < (unsigned)_nhandle), EBADF, -1);
_VALIDATE_CLEAR_OSSERR_RETURN((_osfile(filedes) & FOPEN), EBADF, -1);
/* Lock the file */
_lock_fh(filedes);
__try {
if ( _osfile(filedes) & FOPEN ) {
/* See if the current position equals the end of the file. */
if ( ((here = _lseeki64_nolock(filedes, 0i64, SEEK_CUR)) == -1i64) ||
((end = _lseeki64_nolock(filedes, 0i64, SEEK_END)) == -1i64) )
retval = -1;
else if ( here == end )
retval = 1;
else {
_lseeki64_nolock(filedes, here, SEEK_SET);
retval = 0;
}
}
else {
errno = EBADF;
_doserrno = 0;
retval = -1;
_ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
}
}
__finally {
/* Unlock the file */
_unlock_fh(filedes);
}
/* Done */
return(retval);
}
/***
* _cputws() - _cputws() writes a wide char string to console.
*
* Purpose:
* Writes a wide char string to console.
*
* Entry:
* str: pointer to string
* Exit:
* returns 0 if sucessful. Nonzero if unsucessful
*
*******************************************************************************/
int _CRTIMP __cdecl _cputws(
const wchar_t *str
)
{
size_t len;
int retval = 0;
_VALIDATE_CLEAR_OSSERR_RETURN((str != NULL), EINVAL, -1);
len = wcslen(str);
_mlock(_CONIO_LOCK);
__try {
while(len--)
{
if ( _putwch_nolock(*str++) == WEOF)
{
retval = -1;
break;
}
}
}
__finally {
_munlock(_CONIO_LOCK);
}
return retval;
}
// Changes the mode of a file. The only supported mode bit is _S_IWRITE, which
// controls the user write (read-only) attribute of the file. Returns zero if
// successful; returns -1 and sets errno and _doserrno on failure.
extern "C" int __cdecl _wchmod(wchar_t const* const path, int const mode)
{
_VALIDATE_CLEAR_OSSERR_RETURN(path != nullptr, EINVAL, -1);
WIN32_FILE_ATTRIBUTE_DATA attributes;
if (!GetFileAttributesExW(path, GetFileExInfoStandard, &attributes))
{
__acrt_errno_map_os_error(GetLastError());
return -1;
}
// Set or clear the read-only flag:
if (mode & _S_IWRITE)
{
attributes.dwFileAttributes &= ~FILE_ATTRIBUTE_READONLY;
}
else
{
attributes.dwFileAttributes |= FILE_ATTRIBUTE_READONLY;
}
if (!SetFileAttributesW(path, attributes.dwFileAttributes))
{
__acrt_errno_map_os_error(GetLastError());
return -1;
}
return 0;
}
// _dup2() makes the target file handle a duplicate of the source file handle,
// so that both handles refer to the same file. If the target handle is open
// upon entry, it is closed so that it is not leaked.
//
// Returns 0 if successful; returns -1 and sets errno on failure.
extern "C" int __cdecl _dup2(int const source_fh, int const target_fh)
{
_CHECK_FH_CLEAR_OSSERR_RETURN( source_fh, EBADF, -1 );
_VALIDATE_CLEAR_OSSERR_RETURN((source_fh >= 0 && (unsigned)source_fh < (unsigned)_nhandle), EBADF, -1);
_VALIDATE_CLEAR_OSSERR_RETURN((_osfile(source_fh) & FOPEN), EBADF, -1);
_CHECK_FH_CLEAR_OSSERR_RETURN( target_fh, EBADF, -1 );
_VALIDATE_CLEAR_OSSERR_RETURN(((unsigned)target_fh < _NHANDLE_), EBADF, -1);
// Make sure there is an __crt_lowio_handle_data struct corresponding to the target_fh:
if (target_fh >= _nhandle && __acrt_lowio_ensure_fh_exists(target_fh) != 0)
return -1;
// If the source and target are the same, return success (we've already
// verified that the file handle is open, above). This is for conformance
// with the POSIX specification for dup2.
if (source_fh == target_fh)
return 0;
// Obtain the two file handle locks. In order to prevent deadlock, we
// always obtain the lock for the lower-numbered file handle first:
if (source_fh < target_fh)
{
__acrt_lowio_lock_fh(source_fh);
__acrt_lowio_lock_fh(target_fh);
}
else if (source_fh > target_fh)
{
__acrt_lowio_lock_fh(target_fh);
__acrt_lowio_lock_fh(source_fh);
}
int result = 0;
__try
{
result = dup2_nolock(source_fh, target_fh);
}
__finally
{
// The order in which we unlock the file handles does not matter:
__acrt_lowio_unlock_fh(source_fh);
__acrt_lowio_unlock_fh(target_fh);
}
return result;
}
int __cdecl _dup2 (
int fh1,
int fh2
)
{
int retcode;
/* validate file handles */
_CHECK_FH_CLEAR_OSSERR_RETURN( fh1, EBADF, -1 );
_VALIDATE_CLEAR_OSSERR_RETURN((fh1 >= 0 && (unsigned)fh1 < (unsigned)_nhandle), EBADF, -1);
_VALIDATE_CLEAR_OSSERR_RETURN((_osfile(fh1) & FOPEN), EBADF, -1);
_CHECK_FH_CLEAR_OSSERR_RETURN( fh2, EBADF, -1 );
_VALIDATE_CLEAR_OSSERR_RETURN(((unsigned)fh2 < _NHANDLE_), EBADF, -1);
/*
* Make sure there is an ioinfo struct corresponding to fh2.
*/
if ( (fh2 >= _nhandle) && (extend_ioinfo_arrays(fh2) != 0) ) {
errno = ENOMEM;
return -1;
}
/* get the two file handle locks; in order to prevent deadlock,
get the lowest handle lock first. */
if ( fh1 < fh2 ) {
_lock_fh(fh1);
_lock_fh(fh2);
}
else if ( fh1 > fh2 ) {
_lock_fh(fh2);
_lock_fh(fh1);
}
__try {
retcode = _dup2_nolock(fh1, fh2);
}
__finally {
_unlock_fh(fh1);
_unlock_fh(fh2);
}
return retcode;
}
// Closes the file associated with the given file handle. On success, returns 0.
// On failure, returns -1 and sets errno.
extern "C" int __cdecl _close(int const fh)
{
_CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1);
_VALIDATE_CLEAR_OSSERR_RETURN((fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, -1);
_VALIDATE_CLEAR_OSSERR_RETURN((_osfile(fh) & FOPEN), EBADF, -1);
return __acrt_lowio_lock_fh_and_call(fh, [&]()
{
if (_osfile(fh) & FOPEN)
{
return _close_nolock(fh);
}
else
{
errno = EBADF;
_ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
return -1;
}
});
}
int __cdecl _cputs (
const char *string
)
{
int error = 0; /* error occurred? */
_VALIDATE_CLEAR_OSSERR_RETURN((string != NULL), EINVAL, -1);
_mlock(_CONIO_LOCK); /* acquire console lock */
__try {
/*
* _confh, the handle to the console output, is created the
* first time that either _putch() or _cputs() is called.
*/
if (_confh == -2)
__initconout();
/* write string to console file handle */
/*
* What is more important when writing to console. I don't think if
* speed should matter too much. This justification is used for writing
* the string to Console. Here we are converting each and every
* character to wide character and then writing it to console.
*/
while(*string)
{
if (_putch_nolock(*string++) == EOF) {
error = -1;
break;
}
}
}
__finally {
_munlock(_CONIO_LOCK); /* release console lock */
}
return error;
}
wchar_t * __cdecl _cgetws (
wchar_t *string)
{
size_t sizeInWords;
size_t sizeRead;
errno_t err;
_VALIDATE_CLEAR_OSSERR_RETURN((string != NULL), EINVAL, NULL);
sizeInWords = (size_t)string[0];
err = _cgetws_s(string + 2, sizeInWords, &sizeRead);
if(err != 0)
{
return NULL;
}
string[1] = (wchar_t)sizeRead;
return string + 2;
}
/* now define version that doesn't lock/unlock, validate fh */
int __cdecl _read_nolock (
int fh,
void *inputbuf,
unsigned cnt
)
{
int bytes_read; /* number of bytes read */
char *buffer; /* buffer to read to */
int os_read; /* bytes read on OS call */
char *p, *q; /* pointers into buffer */
wchar_t *pu, *qu; /* wchar_t pointers into buffer for UTF16 */
char peekchr; /* peek-ahead character */
wchar_t wpeekchr; /* peek-ahead wchar_t */
__int64 filepos; /* file position after seek */
ULONG dosretval; /* o.s. return value */
char tmode; /* textmode - ANSI/UTF-8/UTF-16 */
void *buf; /* buffer to read to */
int retval = -2; /* return value */
unsigned inputsize = cnt;
/* validate fh */
_CHECK_FH_CLEAR_OSSERR_RETURN( fh, EBADF, -1 );
_VALIDATE_CLEAR_OSSERR_RETURN((fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, -1);
_VALIDATE_CLEAR_OSSERR_RETURN((_osfile(fh) & FOPEN), EBADF, -1);
bytes_read = 0; /* nothing read yet */
if (cnt == 0 || (_osfile(fh) & FEOFLAG)) {
/* nothing to read or at EOF, so return 0 read */
return 0;
}
_VALIDATE_CLEAR_OSSERR_RETURN( (inputbuf != NULL), EINVAL, -1 );
tmode = _textmode(fh);
switch(tmode) {
case __IOINFO_TM_UTF8 :
/* For a UTF-8 file, we need 2 buffers, because after reading we
need to convert it into UNICODE - MultiByteToWideChar doesn't do
in-place conversions. */
/* MultiByte To WideChar conversion may double the size of the
buffer required & hence we divide cnt by 2 */
/*
* Since we are reading UTF8 stream, cnt bytes read may vary
* from cnt wchar_t characters to cnt/4 wchar_t characters. For
* this reason if we need to read cnt characters, we will
* allocate MBCS buffer of cnt. In case cnt is 0, we will
* have 4 as minimum value. This will make sure we don't
* overflow for reading from pipe case.
*
*
* In this case the numbers of wchar_t characters that we can
* read is cnt/2. This means that the buffer size that we will
* require is cnt/2.
*/
/* For UTF8 we want the count to be an even number */
_VALIDATE_CLEAR_OSSERR_RETURN(((cnt & 1) == 0), EINVAL, -1);
cnt = (cnt/2) < 4 ? 4 : (cnt/2);
buf = _malloc_crt(cnt);
if(!buf) {
errno = ENOMEM;
_doserrno = E_nomem;
return -1;
}
break;
case __IOINFO_TM_UTF16LE :
/* For UTF16 the count always needs to be an even number */
_VALIDATE_CLEAR_OSSERR_RETURN(((cnt & 1) == 0), EINVAL, -1);
cnt &= (~1);
/* Fall Through to default */
default :
/* For non-UTF8 files, we need only 1 buffer - make buf point to
the users input buffer */
buf = inputbuf;
}
buffer = buf;
if ((_osfile(fh) & (FPIPE|FDEV)) && _pipech(fh) != LF && cnt != 0) {
/* a pipe/device and pipe lookahead non-empty: read the lookahead
* char */
*buffer++ = _pipech(fh);
++bytes_read;
--cnt;
_pipech(fh) = LF; /* mark as empty */
/* For UTF16, there maybe one more look ahead char. For UTF8,
there maybe 2 more look ahead chars */
if((tmode != __IOINFO_TM_ANSI) && (_pipech2(fh)[0] != LF) && cnt != 0) {
*buffer++ = _pipech2(fh)[0];
++bytes_read;
--cnt;
_pipech2(fh)[0] = LF; /* mark as empty */
if((tmode == __IOINFO_TM_UTF8) && (_pipech2(fh)[1] != LF) && cnt != 0) {
*buffer++ = _pipech2(fh)[1];
++bytes_read;
--cnt;
_pipech2(fh)[1] = LF; /* mark as empty */
}
}
}
/* read the data */
if ( !ReadFile( (HANDLE)_osfhnd(fh), buffer, cnt, (LPDWORD)&os_read,
NULL ) || os_read < 0 || (size_t)os_read > cnt)
{
/* ReadFile has reported an error. recognize two special cases.
*
* 1. map ERROR_ACCESS_DENIED to EBADF
*
* 2. just return 0 if ERROR_BROKEN_PIPE has occurred. it
* means the handle is a read-handle on a pipe for which
* all write-handles have been closed and all data has been
* read. */
if ( (dosretval = GetLastError()) == ERROR_ACCESS_DENIED ) {
/* wrong read/write mode should return EBADF, not EACCES */
errno = EBADF;
_doserrno = dosretval;
retval = -1;
goto error_return;
}
else if ( dosretval == ERROR_BROKEN_PIPE ) {
retval = 0;
goto error_return;
}
else {
_dosmaperr(dosretval);
retval = -1;
goto error_return;
}
}
bytes_read += os_read; /* update bytes read */
if (_osfile(fh) & FTEXT) {
/* now must translate CR-LFs to LFs in the buffer */
/* For ANSI & UTF8, we read byte by byte.
For UTF16, we need to read 2 bytes (wchar_t's) at a time */
if(tmode != __IOINFO_TM_UTF16LE) {
/* set CRLF flag to indicate LF at beginning of buffer */
if ( (os_read != 0) && (*(char *)buf == LF) )
_osfile(fh) |= FCRLF;
else
_osfile(fh) &= ~FCRLF;
/* convert chars in the buffer: p is src, q is dest */
p = q = buf;
while (p < (char *)buf + bytes_read) {
if (*p == CTRLZ) {
/* if fh is not a device, set ctrl-z flag */
if ( !(_osfile(fh) & FDEV) )
_osfile(fh) |= FEOFLAG;
else
*q++ = *p++;
break; /* stop translating */
}
else if (*p != CR)
*q++ = *p++;
else {
/* *p is CR, so must check next char for LF */
if (p < (char *)buf + bytes_read - 1) {
if (*(p+1) == LF) {
p += 2;
*q++ = LF; /* convert CR-LF to LF */
}
else
*q++ = *p++; /* store char normally */
}
else {
/* This is the hard part. We found a CR at end of
buffer. We must peek ahead to see if next char
is an LF. */
++p;
dosretval = 0;
if ( !ReadFile( (HANDLE)_osfhnd(fh), &peekchr, 1,
(LPDWORD)&os_read, NULL ) )
dosretval = GetLastError();
if (dosretval != 0 || os_read == 0) {
/* couldn't read ahead, store CR */
*q++ = CR;
}
else {
/*
* peekchr now has the extra character -- we now
* have several possibilities:
*
* 1. disk file and char is not LF; just seek
* back and copy CR
* 2. disk file and char is LF; seek back and
* discard CR
* 3. disk file, char is LF but this is a
* one-byte read: store LF, don't seek back
* 4. pipe/device and char is LF; store LF.
* 5. pipe/device and char isn't LF, store CR
* and put char in pipe lookahead buffer.
*/
if (_osfile(fh) & (FDEV|FPIPE)) {
/* non-seekable device */
if (peekchr == LF)
*q++ = LF;
else {
*q++ = CR;
_pipech(fh) = peekchr;
}
}
else {
/* disk file */
if (q == buf && peekchr == LF) {
/* nothing read yet; must make some
progress */
*q++ = LF;
}
else {
/* seek back */
filepos = _lseeki64_nolock(fh, -1i64, FILE_CURRENT);
if (peekchr != LF)
*q++ = CR;
}
}
}
}
}
}
/* we now change bytes_read to reflect the true number of chars
in the buffer */
bytes_read = (int)(q - (char *)buf);
if((tmode == __IOINFO_TM_UTF8) && (bytes_read != 0)) {
/* UTF8 reads need to be converted into UTF16 */
--q; /* q has gone beyond the last char */
/*
* If the last byte is a standalone UTF-8 char. We then
* take the whole buffer. Otherwise we skip back till we
* come to a lead byte. If the leadbyte forms a complete
* UTF-8 character will the remaining part of the buffer,
* then again we take the whole buffer. If not, we skip to
* one byte which should be the final trail byte of the
* previous UTF-8 char or a standalone UTF-8 character
*/
if(_utf8_is_independent(*q)) {
++q;
/*
* Final byte is standalone, we reset q, because we
* will now consider the full buffer which we have read
*/
}
else {
int ctr = 1;
int cnt_trailbytes;
while(!_utf8_is_leadbyte(*q) && ctr <= 4 && q >= (char *)buf) {
--q;
++ctr;
}
cnt_trailbytes = _utf8_no_of_trailbytes(*q);
if(cnt_trailbytes == 0) {
/*
* Should have exited the while by finding a lead
* byte else, the file has incorrect UTF-8 chars
*/
errno = EILSEQ;
retval = -1;
goto error_return;
}
if(cnt_trailbytes + 1 == ctr) {
/*
* The leadbyte + the remaining bytes form a full
* set
*/
q += ctr;
}
else {
/* Seek back */
if (_osfile(fh) & (FDEV|FPIPE)) {
/*
* non-seekable device. Put the extra chars in
* _pipech & _pipech2. We would have a maximum
* of 3 extra chars
*/
_pipech(fh) = *q;
++q;
if(ctr >= 2) {
_pipech2(fh)[0] = *q;
++q;
}
if(ctr == 3) {
_pipech2(fh)[1] = *q;
++q;
}
/*
* We need to point q back to beyond whatever
* we actually took in.
*/
q -= ctr;
}
else {
/* We have read extra chars, so we seek back */
filepos = _lseeki64_nolock(fh, -ctr, FILE_CURRENT);
}
}
}
bytes_read = (int)(q - (char *)buf);
bytes_read = MultiByteToWideChar(
CP_UTF8,
0,
buf,
bytes_read,
inputbuf,
inputsize/2);
if(!bytes_read) {
_dosmaperr(GetLastError());
retval = -1;
goto error_return;
}
/* MultiByteToWideChar returns no of wchar_t's. Double it */
bytes_read = bytes_read*2;
}
}
else {
/* set CRLF flag to indicate LF at beginning of buffer */
if ( (os_read != 0) && (*(wchar_t *)buf == LF) )
_osfile(fh) |= FCRLF;
else
_osfile(fh) &= ~FCRLF;
/* convert chars in the buffer: pu is src, qu is dest */
pu = qu = (wchar_t *)buf;
while ((char *)pu < (char *)buf + bytes_read) {
if (*pu == CTRLZ) {
/* if fh is not a device, set ctrl-z flag */
if ( !(_osfile(fh) & FDEV) )
_osfile(fh) |= FEOFLAG;
else
*qu++ = *pu++;
break; /* stop translating */
}
else if (*pu != CR)
*qu++ = *pu++;
else {
/* *pu is CR, so must check next wchar_t for LF */
if ((char *)pu < (char *)buf + bytes_read - 2) {
if (*(pu+1) == LF) {
pu += 2;
*qu++ = LF; /* convert CR-LF to LF */
}
else
*qu++ = *pu++; /* store char normally */
}
else {
/* This is the hard part. We found a CR at end of
buffer. We must peek ahead to see if next
wchar_t is an LF. */
++pu;
dosretval = 0;
if ( !ReadFile( (HANDLE)_osfhnd(fh), &wpeekchr, 2,
(LPDWORD)&os_read, NULL ) )
dosretval = GetLastError();
if (dosretval != 0 || os_read == 0) {
/* couldn't read ahead, store CR */
*qu++ = CR;
}
else {
/*
* peekchr now has the extra character -- we
* now have several possibilities:
* 1. wchar_t is not LF; just seek back and
* copy CR
* 2. wchar_t is LF; seek back and discard CR
* 3. disk file, wchar_t is LF but this is a
* one-byte read: store LF, don't seek back.
*/
if (_osfile(fh) & (FDEV|FPIPE)) {
/* non-seekable device */
if (wpeekchr == LF)
*qu++ = LF;
else {
char * pwpeekchr = (char *)&wpeekchr;
*qu++ = CR;
_pipech(fh) = *pwpeekchr;
++pwpeekchr;
_pipech2(fh)[0] = *pwpeekchr;
_pipech2(fh)[1] = LF; /* Mark as empty */
}
}
else {
if ((char *)qu == buf && wpeekchr == LF) {
/* nothing read yet; must make some
progress */
*qu++ = LF;
}
else {
/* seek back */
filepos = _lseeki64_nolock(fh, -2, FILE_CURRENT);
if (wpeekchr != LF)
*qu++ = CR;
}
}
}
}
}
}
/* we now change bytes_read to reflect the true number of chars
in the buffer */
bytes_read = (int)((char *)qu - (char *)buf);
}
}
error_return:
if(buf != inputbuf) {
free(buf);
}
return (retval == -2) ? bytes_read : retval ;
}
/* now define version that doesn't lock/unlock, validate fh */
int __cdecl _write_nolock (
int fh,
const void *buf,
unsigned cnt
)
{
int lfcount; /* count of line feeds */
int charcount; /* count of chars written so far */
int written; /* count of chars written on this write */
ULONG dosretval; /* o.s. return value */
char tmode ; /* textmode - ANSI or UTF-16 */
BOOL toConsole = 0; /* true when writing to console */
BOOL isCLocale = 0; /* true when locale handle is C locale */
lfcount = charcount = 0; /* nothing written yet */
if (cnt == 0)
return 0; /* nothing to do */
_VALIDATE_CLEAR_OSSERR_RETURN( (buf != NULL), EINVAL, -1 );
tmode = _textmode(fh);
if(tmode == __IOINFO_TM_UTF16LE ||
tmode == __IOINFO_TM_UTF8)
{
/* For a UTF-16 file, the count must always be an even number */
_VALIDATE_CLEAR_OSSERR_RETURN(((cnt & 1) == 0), EINVAL, -1);
}
if (_osfile(fh) & FAPPEND) {
/* appending - seek to end of file; ignore error, because maybe
file doesn't allow seeking */
#if _INTEGRAL_MAX_BITS >= 64
(void)_lseeki64_nolock(fh, 0, FILE_END);
#else /* _INTEGRAL_MAX_BITS >= 64 */
(void)_lseek_nolock(fh, 0, FILE_END);
#endif /* _INTEGRAL_MAX_BITS >= 64 */
}
/* check for text mode with LF's in the buffer */
/*
* Note that in case the handle belongs to Console, write file will
* generate garbage output. For user to print these characters
* correctly, we will need to print ANSI.
*
* Also note that in case of printing to Console, we still have to
* convert the characters to console codepage.
*/
if (_isatty(fh) && (_osfile(fh) & FTEXT))
{
DWORD dwMode;
_ptiddata ptd = _getptd();
isCLocale = (ptd->ptlocinfo->lc_handle[LC_CTYPE] == _CLOCALEHANDLE);
toConsole = GetConsoleMode((HANDLE)_osfhnd(fh), &dwMode);
}
/* don't need double conversion if it's ANSI mode C locale */
if (toConsole && !(isCLocale && (tmode == __IOINFO_TM_ANSI))) {
UINT consoleCP = GetConsoleCP();
char mboutbuf[MB_LEN_MAX];
wchar_t tmpchar;
int size = 0;
int written = 0;
char *pch;
for (pch = (char *)buf; (unsigned)(pch - (char *)buf) < cnt; ) {
BOOL bCR;
if (tmode == __IOINFO_TM_ANSI) {
bCR = *pch == LF;
/*
* Here we need to do double convert. i.e. convert from
* multibyte to unicode and then from unicode to multibyte in
* Console codepage.
*/
if (!isleadbyte(*pch)) {
if (mbtowc(&tmpchar, pch, 1) == -1) {
break;
}
} else if ((cnt - (pch - (char*)buf)) > 1) {
if (mbtowc(&tmpchar, pch, 2) == -1) {
break;
}
/*
* Increment pch to accomodate DBCS character.
*/
++pch;
} else {
break;
}
++pch;
} else if (tmode == __IOINFO_TM_UTF8 || tmode == __IOINFO_TM_UTF16LE) {
/*
* Note that bCR set above is not valid in case of UNICODE
* stream. We need to set it using unicode character.
*/
tmpchar = *(wchar_t *)pch;
bCR = tmpchar == LF;
pch += 2;
}
if (tmode == __IOINFO_TM_ANSI)
{
if( (size = WideCharToMultiByte(consoleCP,
0,
&tmpchar,
1,
mboutbuf,
sizeof(mboutbuf),
NULL,
NULL)) == 0) {
break;
} else {
if ( WriteFile( (HANDLE)_osfhnd(fh),
mboutbuf,
size,
(LPDWORD)&written,
NULL) ) {
charcount += written;
if (written < size)
break;
} else {
dosretval = GetLastError();
break;
}
}
if (bCR) {
size = 1;
mboutbuf[0] = CR;
if (WriteFile((HANDLE)_osfhnd(fh),
mboutbuf,
size,
(LPDWORD)&written,
NULL) ) {
if (written < size)
break;
lfcount ++;
charcount++;
} else {
dosretval = GetLastError();
break;
}
}
}
else if ( tmode == __IOINFO_TM_UTF8 || tmode == __IOINFO_TM_UTF16LE)
{
if ( _putwch_nolock(tmpchar) == tmpchar )
{
charcount++;
}
else
{
dosretval = GetLastError();
break;
}
if (bCR) /* emit carriage return */
{
size = 1;
tmpchar = CR;
if ( _putwch_nolock(tmpchar) == tmpchar )
{
charcount++;
lfcount++;
}
else
{
dosretval = GetLastError();
break;
}
}
}
}
} else if ( _osfile(fh) & FTEXT ) {
/* text mode, translate LF's to CR/LF's on output */
dosretval = 0; /* no OS error yet */
if(tmode == __IOINFO_TM_ANSI) {
char ch; /* current character */
char *p = NULL, *q = NULL; /* pointers into buf and lfbuf resp. */
char lfbuf[BUF_SIZE];
p = (char *)buf; /* start at beginning of buffer */
while ( (unsigned)(p - (char *)buf) < cnt ) {
q = lfbuf; /* start at beginning of lfbuf */
/* fill the lf buf, except maybe last char */
while ( q - lfbuf < sizeof(lfbuf) - 1 &&
(unsigned)(p - (char *)buf) < cnt ) {
ch = *p++;
if ( ch == LF ) {
++lfcount;
*q++ = CR;
}
*q++ = ch;
}
/* write the lf buf and update total */
if ( WriteFile( (HANDLE)_osfhnd(fh),
lfbuf,
(int)(q - lfbuf),
(LPDWORD)&written,
NULL) )
{
charcount += written;
if (written < q - lfbuf)
break;
}
else {
dosretval = GetLastError();
break;
}
}
} else if ( tmode == __IOINFO_TM_UTF16LE ){
char lfbuf[BUF_SIZE];
wchar_t wch; /* current wide char */
wchar_t *pu = (wchar_t *)buf;
wchar_t *qu = NULL;
while ( (unsigned)((char *)pu - (char *)buf) < cnt ) {
qu = (wchar_t *)lfbuf; /* start at beginning of lfbuf */
/* fill the lf buf, except maybe last wchar_t */
while ( (((char *)qu - lfbuf) < (sizeof(lfbuf) - 2)) &&
((unsigned)((char *)pu - (char *)buf) < cnt )) {
wch = *pu++;
if ( wch == LF ) {
lfcount+=2;
*qu++ = CR;
}
*qu++ = wch;
}
/* write the lf buf and update total */
if ( WriteFile( (HANDLE)_osfhnd(fh),
lfbuf,
(int)((char*)qu - lfbuf),
(LPDWORD)&written,
NULL) )
{
charcount += written;
if (written < ((char *)qu - lfbuf))
break;
}
else {
dosretval = GetLastError();
break;
}
}
} else {
/*
* Let's divide the lfbuf in 1:2 wher 1 is for storing
* widecharacters and 2 if for converting it to UTF8. This takes
* into account the worst case scenario where all the UTF8
* characters are 4 byte long.
*/
char utf8_buf[(BUF_SIZE*2)/3];
wchar_t utf16_buf[BUF_SIZE/6];
wchar_t wch; /* current wide char */
wchar_t *pu = (wchar_t *)buf;
wchar_t *qu = NULL;
pu = (wchar_t *)buf;
while ((unsigned)((char *)pu - (char *)buf) < cnt) {
int bytes_converted = 0;
qu = utf16_buf; /* start at beginning of lfbuf */
while ( (((char *)qu - (char *)utf16_buf) <
(sizeof(utf16_buf) - 2)) &&
((unsigned)((char *)pu - (char *)buf) < cnt )) {
wch = *pu++;
if ( wch == LF ) {
/* no need to count the linefeeds here: we calculate the written chars in another way */
*qu++ = CR;
}
*qu++ = wch;
}
bytes_converted = WideCharToMultiByte(
CP_UTF8,
0,
utf16_buf,
((int)((char *)qu - (char *)utf16_buf))/2,
utf8_buf,
sizeof(utf8_buf),
NULL,
NULL);
if (bytes_converted == 0) {
dosretval = GetLastError();
break;
} else {
/*
* Here we need to make every attempt to write all the
* converted characters. The resaon behind this is,
* incase half the bytes of a UTF8 character is
* written, it may currupt whole of the stream or file.
*
* The loop below will make sure we exit only if all
* the bytes converted are written (which makes sure no
* partial MBCS is written) or there was some error in
* the stream.
*/
int bytes_written = 0;
do {
if (WriteFile(
(HANDLE)_osfhnd(fh),
utf8_buf + bytes_written,
bytes_converted - bytes_written,
&written,
NULL)) {
bytes_written += written;
} else {
dosretval = GetLastError();
break;
}
} while ( bytes_converted > bytes_written);
/*
* Only way the condition below could be true is if
* there was en error. In case of error we need to
* break this loop as well.
*/
if (bytes_converted > bytes_written) {
break;
}
/* if this chunk has been committed successfully, update charcount */
charcount = (int)((char *)pu - (char *)buf);
}
}
}
}
else {
/* binary mode, no translation */
if ( WriteFile( (HANDLE)_osfhnd(fh),
(LPVOID)buf,
cnt,
(LPDWORD)&written,
NULL) )
{
dosretval = 0;
charcount = written;
}
else
dosretval = GetLastError();
}
if (charcount == 0) {
/* If nothing was written, first check if an o.s. error,
otherwise we return -1 and set errno to ENOSPC,
unless a device and first char was CTRL-Z */
if (dosretval != 0) {
/* o.s. error happened, map error */
if (dosretval == ERROR_ACCESS_DENIED) {
/* wrong read/write mode should return EBADF, not
EACCES */
errno = EBADF;
_doserrno = dosretval;
}
else
_dosmaperr(dosretval);
return -1;
}
else if ((_osfile(fh) & FDEV) && *(char *)buf == CTRLZ)
return 0;
else {
errno = ENOSPC;
_doserrno = 0; /* no o.s. error */
return -1;
}
}
else
/* return adjusted bytes written */
return charcount - lfcount;
}
int __cdecl _tchdir (
const _TSCHAR *path
)
{
_TSCHAR env_var[4];
_TSCHAR abspath[MAX_PATH+1];
_TSCHAR *apath=abspath;
int memfree=0;
int r;
int retval = -1;
_VALIDATE_CLEAR_OSSERR_RETURN((path != NULL), EINVAL, -1);
if ( SetCurrentDirectory((LPTSTR)path) )
{
/*
* If the new current directory path is NOT a UNC path, we must
* update the OS environment variable specifying the current
* directory for what is now current drive. To do this, get the
* full current directory, build the environment variable string
* and call SetEnvironmentVariable(). We need to do this because
* SetCurrentDirectory does not (i.e., does not update the
* current-directory-on-drive environment variables) and other
* functions (fullpath, spawn, etc) need them to be set.
*
* If associated with a 'drive', the current directory should
* have the form of the example below:
*
* D:\nt\private\mytests
*
* so that the environment variable should be of the form:
*
* =D:=D:\nt\private\mytests
*
*/
r = GetCurrentDirectory(MAX_PATH+1,(LPTSTR)apath);
if (r > MAX_PATH) {
if ((apath = (_TSCHAR *)_calloc_crt(r+1, sizeof(_TSCHAR))) == NULL) {
r = 0;
} else {
memfree = 1;
}
if (r)
r = GetCurrentDirectory(r+1,(LPTSTR)apath);
}
if (r)
{
/*
* check if it is a UNC name, just return if is
*/
if ( ((apath[0] == _T('\\')) || (apath[0] == _T('/'))) &&
(apath[0] == apath[1]) )
retval = 0;
else {
env_var[0] = _T('=');
env_var[1] = (_TSCHAR) _totupper((_TUCHAR)apath[0]);
env_var[2] = _T(':');
env_var[3] = _T('\0');
if ( SetEnvironmentVariable(env_var, apath) )
retval = 0;
}
}
}
if( 0 != retval )
{
/* error occured -- map error code */
_dosmaperr( GetLastError() );
}
if (memfree)
_free_crt(apath);
return retval;
}
