?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msvcrt: Use fd critical section in _futime64.
[wine/multimedia.git] / dlls / msvcrt / file.c
blob7bdb46877509664f603140702a03fe9cfff52b56
1 /*
2 * msvcrt.dll file functions
3 *
4 * Copyright 1996,1998 Marcus Meissner
5 * Copyright 1996 Jukka Iivonen
6 * Copyright 1997,2000 Uwe Bonnes
7 * Copyright 2000 Jon Griffiths
8 * Copyright 2004 Eric Pouech
9 * Copyright 2004 Juan Lang
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 *
25 * TODO
26 * Use the file flag hints O_SEQUENTIAL, O_RANDOM, O_SHORT_LIVED
27 */
28
29 #include "config.h"
30 #include "wine/port.h"
31
32 #include <stdarg.h>
33 #include <stdio.h>
34 #ifdef HAVE_UNISTD_H
35 # include <unistd.h>
36 #endif
37 #include <sys/types.h>
38 #include <limits.h>
39
40 #include "windef.h"
41 #include "winbase.h"
42 #include "winternl.h"
43 #include "msvcrt.h"
44 #include "mtdll.h"
45
46 #include "wine/unicode.h"
47
48 #include "wine/debug.h"
49
50 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
51
52 /* for stat mode, permissions apply to all,owner and group */
53 #define ALL_S_IREAD (MSVCRT__S_IREAD | (MSVCRT__S_IREAD >> 3) | (MSVCRT__S_IREAD >> 6))
54 #define ALL_S_IWRITE (MSVCRT__S_IWRITE | (MSVCRT__S_IWRITE >> 3) | (MSVCRT__S_IWRITE >> 6))
55 #define ALL_S_IEXEC (MSVCRT__S_IEXEC | (MSVCRT__S_IEXEC >> 3) | (MSVCRT__S_IEXEC >> 6))
56
57 /* _access() bit flags FIXME: incomplete */
58 #define MSVCRT_W_OK 0x02
59 #define MSVCRT_R_OK 0x04
60
61 /* values for wxflag in file descriptor */
62 #define WX_OPEN 0x01
63 #define WX_ATEOF 0x02
64 #define WX_READNL 0x04 /* read started with \n */
65 #define WX_PIPE 0x08
66 #define WX_DONTINHERIT 0x10
67 #define WX_APPEND 0x20
68 #define WX_TTY 0x40
69 #define WX_TEXT 0x80
70
71 /* values for exflag - it's used differently in msvcr90.dll*/
72 #define EF_UTF8 0x01
73 #define EF_UTF16 0x02
74 #define EF_CRIT_INIT 0x04
75 #define EF_UNK_UNICODE 0x08
76
77 static char utf8_bom[3] = { 0xef, 0xbb, 0xbf };
78 static char utf16_bom[2] = { 0xff, 0xfe };
79
80 /* FIXME: this should be allocated dynamically */
81 #define MSVCRT_MAX_FILES 2048
82 #define MSVCRT_FD_BLOCK_SIZE 32
83
84 #define MSVCRT_INTERNAL_BUFSIZ 4096
85
86 /* ioinfo structure size is different in msvcrXX.dll's */
87 typedef struct {
88 HANDLE handle;
89 unsigned char wxflag;
90 char lookahead[3];
91 int exflag;
92 CRITICAL_SECTION crit;
93 #if _MSVCR_VER >= 80
94 char textmode : 7;
95 char unicode : 1;
96 char pipech2[2];
97 __int64 startpos;
98 BOOL utf8translations;
99 #endif
100 #if _MSVCR_VER >= 90
101 char dbcsBuffer;
102 BOOL dbcsBufferUsed;
103 #endif
104 } ioinfo;
105
106 /*********************************************************************
107 * __pioinfo (MSVCRT.@)
108 * array of pointers to ioinfo arrays [32]
109 */
110 ioinfo * MSVCRT___pioinfo[MSVCRT_MAX_FILES/MSVCRT_FD_BLOCK_SIZE] = { 0 };
111
112 /*********************************************************************
113 * __badioinfo (MSVCRT.@)
114 */
115 ioinfo MSVCRT___badioinfo = { INVALID_HANDLE_VALUE, WX_TEXT };
116
117 static int MSVCRT_fdstart = 3; /* first unallocated fd */
118 static int MSVCRT_fdend = 3; /* highest allocated fd */
119
120 typedef struct {
121 MSVCRT_FILE file;
122 CRITICAL_SECTION crit;
123 } file_crit;
124
125 MSVCRT_FILE MSVCRT__iob[_IOB_ENTRIES] = { { 0 } };
126 static file_crit* MSVCRT_fstream[MSVCRT_MAX_FILES/MSVCRT_FD_BLOCK_SIZE];
127 static int MSVCRT_max_streams = 512, MSVCRT_stream_idx;
128
129 /* INTERNAL: process umask */
130 static int MSVCRT_umask = 0;
131
132 /* INTERNAL: static data for tmpnam and _wtmpname functions */
133 static int tmpnam_unique;
134
135 static const unsigned int EXE = 'e' << 16 | 'x' << 8 | 'e';
136 static const unsigned int BAT = 'b' << 16 | 'a' << 8 | 't';
137 static const unsigned int CMD = 'c' << 16 | 'm' << 8 | 'd';
138 static const unsigned int COM = 'c' << 16 | 'o' << 8 | 'm';
139
140 #define TOUL(x) (ULONGLONG)(x)
141 static const ULONGLONG WCEXE = TOUL('e') << 32 | TOUL('x') << 16 | TOUL('e');
142 static const ULONGLONG WCBAT = TOUL('b') << 32 | TOUL('a') << 16 | TOUL('t');
143 static const ULONGLONG WCCMD = TOUL('c') << 32 | TOUL('m') << 16 | TOUL('d');
144 static const ULONGLONG WCCOM = TOUL('c') << 32 | TOUL('o') << 16 | TOUL('m');
145
146 /* This critical section protects the tables MSVCRT___pioinfo and MSVCRT_fstreams,
147 * and their related indexes, MSVCRT_fdstart, MSVCRT_fdend,
148 * and MSVCRT_stream_idx, from race conditions.
149 * It doesn't protect against race conditions manipulating the underlying files
150 * or flags; doing so would probably be better accomplished with per-file
151 * protection, rather than locking the whole table for every change.
152 */
153 static CRITICAL_SECTION MSVCRT_file_cs;
154 static CRITICAL_SECTION_DEBUG MSVCRT_file_cs_debug =
155 {
156 0, 0, &MSVCRT_file_cs,
157 { &MSVCRT_file_cs_debug.ProcessLocksList, &MSVCRT_file_cs_debug.ProcessLocksList },
158 0, 0, { (DWORD_PTR)(__FILE__ ": MSVCRT_file_cs") }
159 };
160 static CRITICAL_SECTION MSVCRT_file_cs = { &MSVCRT_file_cs_debug, -1, 0, 0, 0, 0 };
161 #define LOCK_FILES() do { EnterCriticalSection(&MSVCRT_file_cs); } while (0)
162 #define UNLOCK_FILES() do { LeaveCriticalSection(&MSVCRT_file_cs); } while (0)
163
164 static void msvcrt_stat64_to_stat(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stat *buf)
165 {
166 buf->st_dev = buf64->st_dev;
167 buf->st_ino = buf64->st_ino;
168 buf->st_mode = buf64->st_mode;
169 buf->st_nlink = buf64->st_nlink;
170 buf->st_uid = buf64->st_uid;
171 buf->st_gid = buf64->st_gid;
172 buf->st_rdev = buf64->st_rdev;
173 buf->st_size = buf64->st_size;
174 buf->st_atime = buf64->st_atime;
175 buf->st_mtime = buf64->st_mtime;
176 buf->st_ctime = buf64->st_ctime;
177 }
178
179 static void msvcrt_stat64_to_stati64(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stati64 *buf)
180 {
181 buf->st_dev = buf64->st_dev;
182 buf->st_ino = buf64->st_ino;
183 buf->st_mode = buf64->st_mode;
184 buf->st_nlink = buf64->st_nlink;
185 buf->st_uid = buf64->st_uid;
186 buf->st_gid = buf64->st_gid;
187 buf->st_rdev = buf64->st_rdev;
188 buf->st_size = buf64->st_size;
189 buf->st_atime = buf64->st_atime;
190 buf->st_mtime = buf64->st_mtime;
191 buf->st_ctime = buf64->st_ctime;
192 }
193
194 static void msvcrt_stat64_to_stat32(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stat32 *buf)
195 {
196 buf->st_dev = buf64->st_dev;
197 buf->st_ino = buf64->st_ino;
198 buf->st_mode = buf64->st_mode;
199 buf->st_nlink = buf64->st_nlink;
200 buf->st_uid = buf64->st_uid;
201 buf->st_gid = buf64->st_gid;
202 buf->st_rdev = buf64->st_rdev;
203 buf->st_size = buf64->st_size;
204 buf->st_atime = buf64->st_atime;
205 buf->st_mtime = buf64->st_mtime;
206 buf->st_ctime = buf64->st_ctime;
207 }
208
209 static void msvcrt_stat64_to_stat64i32(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stat64i32 *buf)
210 {
211 buf->st_dev = buf64->st_dev;
212 buf->st_ino = buf64->st_ino;
213 buf->st_mode = buf64->st_mode;
214 buf->st_nlink = buf64->st_nlink;
215 buf->st_uid = buf64->st_uid;
216 buf->st_gid = buf64->st_gid;
217 buf->st_rdev = buf64->st_rdev;
218 buf->st_size = buf64->st_size;
219 buf->st_atime = buf64->st_atime;
220 buf->st_mtime = buf64->st_mtime;
221 buf->st_ctime = buf64->st_ctime;
222 }
223
224 static void msvcrt_stat64_to_stat32i64(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stat32i64 *buf)
225 {
226 buf->st_dev = buf64->st_dev;
227 buf->st_ino = buf64->st_ino;
228 buf->st_mode = buf64->st_mode;
229 buf->st_nlink = buf64->st_nlink;
230 buf->st_uid = buf64->st_uid;
231 buf->st_gid = buf64->st_gid;
232 buf->st_rdev = buf64->st_rdev;
233 buf->st_size = buf64->st_size;
234 buf->st_atime = buf64->st_atime;
235 buf->st_mtime = buf64->st_mtime;
236 buf->st_ctime = buf64->st_ctime;
237 }
238
239 static void time_to_filetime( MSVCRT___time64_t time, FILETIME *ft )
240 {
241 /* 1601 to 1970 is 369 years plus 89 leap days */
242 static const __int64 secs_1601_to_1970 = ((369 * 365 + 89) * (__int64)86400);
243
244 __int64 ticks = (time + secs_1601_to_1970) * 10000000;
245 ft->dwHighDateTime = ticks >> 32;
246 ft->dwLowDateTime = ticks;
247 }
248
249 static inline ioinfo* get_ioinfo_nolock(int fd)
250 {
251 ioinfo *ret = NULL;
252 if(fd>=0 && fd<MSVCRT_MAX_FILES)
253 ret = MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE];
254 if(!ret)
255 return &MSVCRT___badioinfo;
256
257 return ret + (fd%MSVCRT_FD_BLOCK_SIZE);
258 }
259
260 static inline ioinfo* get_ioinfo(int fd)
261 {
262 ioinfo *ret = get_ioinfo_nolock(fd);
263 if(!(ret->exflag & EF_CRIT_INIT)) {
264 LOCK_FILES();
265 if(!(ret->exflag & EF_CRIT_INIT)) {
266 InitializeCriticalSection(&ret->crit);
267 ret->exflag |= EF_CRIT_INIT;
268 }
269 UNLOCK_FILES();
270 }
271 EnterCriticalSection(&ret->crit);
272 return ret;
273 }
274
275 static inline void release_ioinfo(ioinfo *info)
276 {
277 if(info->exflag & EF_CRIT_INIT)
278 LeaveCriticalSection(&info->crit);
279 }
280
281 static inline MSVCRT_FILE* msvcrt_get_file(int i)
282 {
283 file_crit *ret;
284
285 if(i >= MSVCRT_max_streams)
286 return NULL;
287
288 if(i < _IOB_ENTRIES)
289 return &MSVCRT__iob[i];
290
291 ret = MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE];
292 if(!ret) {
293 MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE] = MSVCRT_calloc(MSVCRT_FD_BLOCK_SIZE, sizeof(file_crit));
294 if(!MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE]) {
295 ERR("out of memory\n");
296 *MSVCRT__errno() = MSVCRT_ENOMEM;
297 return NULL;
298 }
299
300 ret = MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE] + (i%MSVCRT_FD_BLOCK_SIZE);
301 } else
302 ret += i%MSVCRT_FD_BLOCK_SIZE;
303
304 return &ret->file;
305 }
306
307 static inline BOOL msvcrt_is_valid_fd(int fd)
308 {
309 return fd >= 0 && fd < MSVCRT_fdend && (get_ioinfo_nolock(fd)->wxflag & WX_OPEN);
310 }
311
312 /* INTERNAL: Get the HANDLE for a fd
313 * This doesn't lock the table, because a failure will result in
314 * INVALID_HANDLE_VALUE being returned, which should be handled correctly. If
315 * it returns a valid handle which is about to be closed, a subsequent call
316 * will fail, most likely in a sane way.
317 */
318 static HANDLE msvcrt_fdtoh(int fd)
319 {
320 if (!msvcrt_is_valid_fd(fd))
321 {
322 WARN(":fd (%d) - no handle!\n",fd);
323 *MSVCRT___doserrno() = 0;
324 *MSVCRT__errno() = MSVCRT_EBADF;
325 return INVALID_HANDLE_VALUE;
326 }
327 if (get_ioinfo_nolock(fd)->handle == INVALID_HANDLE_VALUE)
328 WARN("returning INVALID_HANDLE_VALUE for %d\n", fd);
329 return get_ioinfo_nolock(fd)->handle;
330 }
331
332 /* INTERNAL: free a file entry fd */
333 static void msvcrt_free_fd(int fd)
334 {
335 ioinfo *fdinfo = get_ioinfo(fd);
336
337 if(fdinfo != &MSVCRT___badioinfo)
338 {
339 fdinfo->handle = INVALID_HANDLE_VALUE;
340 fdinfo->wxflag = 0;
341 }
342 TRACE(":fd (%d) freed\n",fd);
343
344 if (fd < 3)
345 {
346 switch (fd)
347 {
348 case 0:
349 SetStdHandle(STD_INPUT_HANDLE, 0);
350 break;
351 case 1:
352 SetStdHandle(STD_OUTPUT_HANDLE, 0);
353 break;
354 case 2:
355 SetStdHandle(STD_ERROR_HANDLE, 0);
356 break;
357 }
358 }
359 release_ioinfo(fdinfo);
360
361 LOCK_FILES();
362 if (fd == MSVCRT_fdend - 1)
363 MSVCRT_fdend--;
364 if (fd < MSVCRT_fdstart)
365 MSVCRT_fdstart = fd;
366 UNLOCK_FILES();
367 }
368
369 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE, starting from fd */
370 /* caller must hold the files lock */
371 static int msvcrt_set_fd(HANDLE hand, int flag, int fd)
372 {
373 ioinfo *fdinfo;
374
375 if (fd >= MSVCRT_MAX_FILES)
376 {
377 WARN(":files exhausted!\n");
378 *MSVCRT__errno() = MSVCRT_ENFILE;
379 return -1;
380 }
381
382 fdinfo = get_ioinfo_nolock(fd);
383 if(fdinfo == &MSVCRT___badioinfo) {
384 int i;
385
386 MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE] = MSVCRT_calloc(MSVCRT_FD_BLOCK_SIZE, sizeof(ioinfo));
387 if(!MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE]) {
388 WARN(":out of memory!\n");
389 *MSVCRT__errno() = MSVCRT_ENOMEM;
390 return -1;
391 }
392
393 for(i=0; i<MSVCRT_FD_BLOCK_SIZE; i++)
394 MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE][i].handle = INVALID_HANDLE_VALUE;
395
396 fdinfo = get_ioinfo_nolock(fd);
397 }
398
399 fdinfo->handle = hand;
400 fdinfo->wxflag = WX_OPEN | (flag & (WX_DONTINHERIT | WX_APPEND | WX_TEXT | WX_PIPE | WX_TTY));
401 fdinfo->lookahead[0] = '\n';
402 fdinfo->lookahead[1] = '\n';
403 fdinfo->lookahead[2] = '\n';
404 if(!(fdinfo->exflag & EF_CRIT_INIT))
405 InitializeCriticalSection(&fdinfo->crit);
406 fdinfo->exflag = EF_CRIT_INIT;
407
408 /* locate next free slot */
409 if (fd == MSVCRT_fdstart && fd == MSVCRT_fdend)
410 MSVCRT_fdstart = MSVCRT_fdend + 1;
411 else
412 while (MSVCRT_fdstart < MSVCRT_fdend &&
413 get_ioinfo_nolock(MSVCRT_fdstart)->handle != INVALID_HANDLE_VALUE)
414 MSVCRT_fdstart++;
415 /* update last fd in use */
416 if (fd >= MSVCRT_fdend)
417 MSVCRT_fdend = fd + 1;
418 TRACE("fdstart is %d, fdend is %d\n", MSVCRT_fdstart, MSVCRT_fdend);
419
420 switch (fd)
421 {
422 case 0: SetStdHandle(STD_INPUT_HANDLE, hand); break;
423 case 1: SetStdHandle(STD_OUTPUT_HANDLE, hand); break;
424 case 2: SetStdHandle(STD_ERROR_HANDLE, hand); break;
425 }
426
427 return fd;
428 }
429
430 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE */
431 static int msvcrt_alloc_fd(HANDLE hand, int flag)
432 {
433 int ret;
434
435 LOCK_FILES();
436 TRACE(":handle (%p) allocating fd (%d)\n",hand,MSVCRT_fdstart);
437 ret = msvcrt_set_fd(hand, flag, MSVCRT_fdstart);
438 UNLOCK_FILES();
439 return ret;
440 }
441
442 /* INTERNAL: Allocate a FILE* for an fd slot */
443 /* caller must hold the files lock */
444 static MSVCRT_FILE* msvcrt_alloc_fp(void)
445 {
446 int i;
447 MSVCRT_FILE *file;
448
449 for (i = 3; i < MSVCRT_max_streams; i++)
450 {
451 file = msvcrt_get_file(i);
452 if (!file)
453 return NULL;
454
455 if (file->_flag == 0)
456 {
457 if (i == MSVCRT_stream_idx)
458 {
459 if (file<MSVCRT__iob || file>=MSVCRT__iob+_IOB_ENTRIES)
460 {
461 InitializeCriticalSection(&((file_crit*)file)->crit);
462 ((file_crit*)file)->crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": file_crit.crit");
463 }
464 MSVCRT_stream_idx++;
465 }
466 return file;
467 }
468 }
469
470 return NULL;
471 }
472
473 /* INTERNAL: initialize a FILE* from an open fd */
474 static int msvcrt_init_fp(MSVCRT_FILE* file, int fd, unsigned stream_flags)
475 {
476 TRACE(":fd (%d) allocating FILE*\n",fd);
477 if (!msvcrt_is_valid_fd(fd))
478 {
479 WARN(":invalid fd %d\n",fd);
480 *MSVCRT___doserrno() = 0;
481 *MSVCRT__errno() = MSVCRT_EBADF;
482 return -1;
483 }
484 file->_ptr = file->_base = NULL;
485 file->_cnt = 0;
486 file->_file = fd;
487 file->_flag = stream_flags;
488 file->_tmpfname = NULL;
489
490 TRACE(":got FILE* (%p)\n",file);
491 return 0;
492 }
493
494 /* INTERNAL: Create an inheritance data block (for spawned process)
495 * The inheritance block is made of:
496 * 00 int nb of file descriptor (NBFD)
497 * 04 char file flags (wxflag): repeated for each fd
498 * 4+NBFD HANDLE file handle: repeated for each fd
499 */
500 unsigned msvcrt_create_io_inherit_block(WORD *size, BYTE **block)
501 {
502 int fd;
503 char* wxflag_ptr;
504 HANDLE* handle_ptr;
505 ioinfo* fdinfo;
506
507 *size = sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE)) * MSVCRT_fdend;
508 *block = MSVCRT_calloc(*size, 1);
509 if (!*block)
510 {
511 *size = 0;
512 return FALSE;
513 }
514 wxflag_ptr = (char*)*block + sizeof(unsigned);
515 handle_ptr = (HANDLE*)(wxflag_ptr + MSVCRT_fdend * sizeof(char));
516
517 *(unsigned*)*block = MSVCRT_fdend;
518 for (fd = 0; fd < MSVCRT_fdend; fd++)
519 {
520 /* to be inherited, we need it to be open, and that DONTINHERIT isn't set */
521 fdinfo = get_ioinfo_nolock(fd);
522 if ((fdinfo->wxflag & (WX_OPEN | WX_DONTINHERIT)) == WX_OPEN)
523 {
524 *wxflag_ptr = fdinfo->wxflag;
525 *handle_ptr = fdinfo->handle;
526 }
527 else
528 {
529 *wxflag_ptr = 0;
530 *handle_ptr = INVALID_HANDLE_VALUE;
531 }
532 wxflag_ptr++; handle_ptr++;
533 }
534 return TRUE;
535 }
536
537 /* INTERNAL: Set up all file descriptors,
538 * as well as default streams (stdin, stderr and stdout)
539 */
540 void msvcrt_init_io(void)
541 {
542 STARTUPINFOA si;
543 int i;
544 ioinfo *fdinfo;
545
546 GetStartupInfoA(&si);
547 if (si.cbReserved2 >= sizeof(unsigned int) && si.lpReserved2 != NULL)
548 {
549 BYTE* wxflag_ptr;
550 HANDLE* handle_ptr;
551 unsigned int count;
552
553 count = *(unsigned*)si.lpReserved2;
554 wxflag_ptr = si.lpReserved2 + sizeof(unsigned);
555 handle_ptr = (HANDLE*)(wxflag_ptr + count);
556
557 count = min(count, (si.cbReserved2 - sizeof(unsigned)) / (sizeof(HANDLE) + 1));
558 count = min(count, MSVCRT_MAX_FILES);
559 for (i = 0; i < count; i++)
560 {
561 if ((*wxflag_ptr & WX_OPEN) && *handle_ptr != INVALID_HANDLE_VALUE)
562 msvcrt_set_fd(*handle_ptr, *wxflag_ptr, i);
563
564 wxflag_ptr++; handle_ptr++;
565 }
566 MSVCRT_fdend = max( 3, count );
567 for (MSVCRT_fdstart = 3; MSVCRT_fdstart < MSVCRT_fdend; MSVCRT_fdstart++)
568 if (get_ioinfo_nolock(MSVCRT_fdstart)->handle == INVALID_HANDLE_VALUE) break;
569 }
570
571 fdinfo = get_ioinfo_nolock(MSVCRT_STDIN_FILENO);
572 if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE) {
573 HANDLE h = GetStdHandle(STD_INPUT_HANDLE);
574 DWORD type = GetFileType(h);
575
576 msvcrt_set_fd(h, WX_OPEN|WX_TEXT|((type&0xf)==FILE_TYPE_CHAR ? WX_TTY : 0)
577 |((type&0xf)==FILE_TYPE_PIPE ? WX_PIPE : 0), MSVCRT_STDIN_FILENO);
578 }
579
580 fdinfo = get_ioinfo_nolock(MSVCRT_STDOUT_FILENO);
581 if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE) {
582 HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
583 DWORD type = GetFileType(h);
584
585 msvcrt_set_fd(h, WX_OPEN|WX_TEXT|((type&0xf)==FILE_TYPE_CHAR ? WX_TTY : 0)
586 |((type&0xf)==FILE_TYPE_PIPE ? WX_PIPE : 0), MSVCRT_STDOUT_FILENO);
587 }
588
589 fdinfo = get_ioinfo_nolock(MSVCRT_STDERR_FILENO);
590 if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE) {
591 HANDLE h = GetStdHandle(STD_ERROR_HANDLE);
592 DWORD type = GetFileType(h);
593
594 msvcrt_set_fd(h, WX_OPEN|WX_TEXT|((type&0xf)==FILE_TYPE_CHAR ? WX_TTY : 0)
595 |((type&0xf)==FILE_TYPE_PIPE ? WX_PIPE : 0), MSVCRT_STDERR_FILENO);
596 }
597
598 TRACE(":handles (%p)(%p)(%p)\n", get_ioinfo_nolock(MSVCRT_STDIN_FILENO)->handle,
599 get_ioinfo_nolock(MSVCRT_STDOUT_FILENO)->handle,
600 get_ioinfo_nolock(MSVCRT_STDERR_FILENO)->handle);
601
602 memset(MSVCRT__iob,0,3*sizeof(MSVCRT_FILE));
603 for (i = 0; i < 3; i++)
604 {
605 /* FILE structs for stdin/out/err are static and never deleted */
606 MSVCRT__iob[i]._file = i;
607 MSVCRT__iob[i]._tmpfname = NULL;
608 MSVCRT__iob[i]._flag = (i == 0) ? MSVCRT__IOREAD : MSVCRT__IOWRT;
609 }
610 MSVCRT_stream_idx = 3;
611 }
612
613 /* INTERNAL: Flush stdio file buffer */
614 static int msvcrt_flush_buffer(MSVCRT_FILE* file)
615 {
616 if((file->_flag & (MSVCRT__IOREAD|MSVCRT__IOWRT)) == MSVCRT__IOWRT &&
617 file->_flag & (MSVCRT__IOMYBUF|MSVCRT__USERBUF)) {
618 int cnt=file->_ptr-file->_base;
619 if(cnt>0 && MSVCRT__write(file->_file, file->_base, cnt) != cnt) {
620 file->_flag |= MSVCRT__IOERR;
621 return MSVCRT_EOF;
622 }
623
624 if(file->_flag & MSVCRT__IORW)
625 file->_flag &= ~MSVCRT__IOWRT;
626 }
627
628 file->_ptr=file->_base;
629 file->_cnt=0;
630 return 0;
631 }
632
633 /*********************************************************************
634 * _isatty (MSVCRT.@)
635 */
636 int CDECL MSVCRT__isatty(int fd)
637 {
638 TRACE(":fd (%d)\n",fd);
639
640 return get_ioinfo_nolock(fd)->wxflag & WX_TTY;
641 }
642
643 /* INTERNAL: Allocate stdio file buffer */
644 static BOOL msvcrt_alloc_buffer(MSVCRT_FILE* file)
645 {
646 if((file->_file==MSVCRT_STDOUT_FILENO || file->_file==MSVCRT_STDERR_FILENO)
647 && MSVCRT__isatty(file->_file))
648 return FALSE;
649
650 file->_base = MSVCRT_calloc(MSVCRT_INTERNAL_BUFSIZ,1);
651 if(file->_base) {
652 file->_bufsiz = MSVCRT_INTERNAL_BUFSIZ;
653 file->_flag |= MSVCRT__IOMYBUF;
654 } else {
655 file->_base = (char*)(&file->_charbuf);
656 file->_bufsiz = 2;
657 file->_flag |= MSVCRT__IONBF;
658 }
659 file->_ptr = file->_base;
660 file->_cnt = 0;
661 return TRUE;
662 }
663
664 /* INTERNAL: Allocate temporary buffer for stdout and stderr */
665 static BOOL add_std_buffer(MSVCRT_FILE *file)
666 {
667 static char buffers[2][MSVCRT_BUFSIZ];
668
669 if((file->_file!=MSVCRT_STDOUT_FILENO && file->_file!=MSVCRT_STDERR_FILENO)
670 || (file->_flag & (MSVCRT__IONBF | MSVCRT__IOMYBUF | MSVCRT__USERBUF))
671 || !MSVCRT__isatty(file->_file))
672 return FALSE;
673
674 file->_ptr = file->_base = buffers[file->_file == MSVCRT_STDOUT_FILENO ? 0 : 1];
675 file->_bufsiz = file->_cnt = MSVCRT_BUFSIZ;
676 file->_flag |= MSVCRT__USERBUF;
677 return TRUE;
678 }
679
680 /* INTERNAL: Removes temporary buffer from stdout or stderr */
681 /* Only call this function when add_std_buffer returned TRUE */
682 static void remove_std_buffer(MSVCRT_FILE *file)
683 {
684 msvcrt_flush_buffer(file);
685 file->_ptr = file->_base = NULL;
686 file->_bufsiz = file->_cnt = 0;
687 file->_flag &= ~MSVCRT__USERBUF;
688 }
689
690 /* INTERNAL: Convert integer to base32 string (0-9a-v), 0 becomes "" */
691 static int msvcrt_int_to_base32(int num, char *str)
692 {
693 char *p;
694 int n = num;
695 int digits = 0;
696
697 while (n != 0)
698 {
699 n >>= 5;
700 digits++;
701 }
702 p = str + digits;
703 *p = 0;
704 while (--p >= str)
705 {
706 *p = (num & 31) + '0';
707 if (*p > '9')
708 *p += ('a' - '0' - 10);
709 num >>= 5;
710 }
711
712 return digits;
713 }
714
715 /* INTERNAL: wide character version of msvcrt_int_to_base32 */
716 static int msvcrt_int_to_base32_w(int num, MSVCRT_wchar_t *str)
717 {
718 MSVCRT_wchar_t *p;
719 int n = num;
720 int digits = 0;
721
722 while (n != 0)
723 {
724 n >>= 5;
725 digits++;
726 }
727 p = str + digits;
728 *p = 0;
729 while (--p >= str)
730 {
731 *p = (num & 31) + '0';
732 if (*p > '9')
733 *p += ('a' - '0' - 10);
734 num >>= 5;
735 }
736
737 return digits;
738 }
739
740 /*********************************************************************
741 * __iob_func(MSVCRT.@)
742 */
743 MSVCRT_FILE * CDECL MSVCRT___iob_func(void)
744 {
745 return &MSVCRT__iob[0];
746 }
747
748 /*********************************************************************
749 * _access (MSVCRT.@)
750 */
751 int CDECL MSVCRT__access(const char *filename, int mode)
752 {
753 DWORD attr = GetFileAttributesA(filename);
754
755 TRACE("(%s,%d) %d\n",filename,mode,attr);
756
757 if (!filename || attr == INVALID_FILE_ATTRIBUTES)
758 {
759 msvcrt_set_errno(GetLastError());
760 return -1;
761 }
762 if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
763 {
764 msvcrt_set_errno(ERROR_ACCESS_DENIED);
765 return -1;
766 }
767 return 0;
768 }
769
770 /*********************************************************************
771 * _access_s (MSVCRT.@)
772 */
773 int CDECL MSVCRT__access_s(const char *filename, int mode)
774 {
775 if (!MSVCRT_CHECK_PMT(filename != NULL)) return *MSVCRT__errno();
776 if (!MSVCRT_CHECK_PMT((mode & ~(MSVCRT_R_OK | MSVCRT_W_OK)) == 0)) return *MSVCRT__errno();
777
778 if (MSVCRT__access(filename, mode) == -1)
779 return *MSVCRT__errno();
780 return 0;
781 }
782
783 /*********************************************************************
784 * _waccess (MSVCRT.@)
785 */
786 int CDECL MSVCRT__waccess(const MSVCRT_wchar_t *filename, int mode)
787 {
788 DWORD attr = GetFileAttributesW(filename);
789
790 TRACE("(%s,%d) %d\n",debugstr_w(filename),mode,attr);
791
792 if (!filename || attr == INVALID_FILE_ATTRIBUTES)
793 {
794 msvcrt_set_errno(GetLastError());
795 return -1;
796 }
797 if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
798 {
799 msvcrt_set_errno(ERROR_ACCESS_DENIED);
800 return -1;
801 }
802 return 0;
803 }
804
805 /*********************************************************************
806 * _waccess_s (MSVCRT.@)
807 */
808 int CDECL MSVCRT__waccess_s(const MSVCRT_wchar_t *filename, int mode)
809 {
810 if (!MSVCRT_CHECK_PMT(filename != NULL)) return *MSVCRT__errno();
811 if (!MSVCRT_CHECK_PMT((mode & ~(MSVCRT_R_OK | MSVCRT_W_OK)) == 0)) return *MSVCRT__errno();
812
813 if (MSVCRT__waccess(filename, mode) == -1)
814 return *MSVCRT__errno();
815 return 0;
816 }
817
818 /*********************************************************************
819 * _chmod (MSVCRT.@)
820 */
821 int CDECL MSVCRT__chmod(const char *path, int flags)
822 {
823 DWORD oldFlags = GetFileAttributesA(path);
824
825 if (oldFlags != INVALID_FILE_ATTRIBUTES)
826 {
827 DWORD newFlags = (flags & MSVCRT__S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
828 oldFlags | FILE_ATTRIBUTE_READONLY;
829
830 if (newFlags == oldFlags || SetFileAttributesA(path, newFlags))
831 return 0;
832 }
833 msvcrt_set_errno(GetLastError());
834 return -1;
835 }
836
837 /*********************************************************************
838 * _wchmod (MSVCRT.@)
839 */
840 int CDECL MSVCRT__wchmod(const MSVCRT_wchar_t *path, int flags)
841 {
842 DWORD oldFlags = GetFileAttributesW(path);
843
844 if (oldFlags != INVALID_FILE_ATTRIBUTES)
845 {
846 DWORD newFlags = (flags & MSVCRT__S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
847 oldFlags | FILE_ATTRIBUTE_READONLY;
848
849 if (newFlags == oldFlags || SetFileAttributesW(path, newFlags))
850 return 0;
851 }
852 msvcrt_set_errno(GetLastError());
853 return -1;
854 }
855
856 /*********************************************************************
857 * _unlink (MSVCRT.@)
858 */
859 int CDECL MSVCRT__unlink(const char *path)
860 {
861 TRACE("%s\n",debugstr_a(path));
862 if(DeleteFileA(path))
863 return 0;
864 TRACE("failed (%d)\n",GetLastError());
865 msvcrt_set_errno(GetLastError());
866 return -1;
867 }
868
869 /*********************************************************************
870 * _wunlink (MSVCRT.@)
871 */
872 int CDECL MSVCRT__wunlink(const MSVCRT_wchar_t *path)
873 {
874 TRACE("(%s)\n",debugstr_w(path));
875 if(DeleteFileW(path))
876 return 0;
877 TRACE("failed (%d)\n",GetLastError());
878 msvcrt_set_errno(GetLastError());
879 return -1;
880 }
881
882 /*********************************************************************
883 * _commit (MSVCRT.@)
884 */
885 int CDECL MSVCRT__commit(int fd)
886 {
887 ioinfo *info = get_ioinfo(fd);
888 int ret;
889
890 TRACE(":fd (%d) handle (%p)\n", fd, info->handle);
891
892 if (info->handle == INVALID_HANDLE_VALUE)
893 ret = -1;
894 else if (!FlushFileBuffers(info->handle))
895 {
896 if (GetLastError() == ERROR_INVALID_HANDLE)
897 {
898 /* FlushFileBuffers fails for console handles
899 * so we ignore this error.
900 */
901 ret = 0;
902 }
903 else
904 {
905 TRACE(":failed-last error (%d)\n",GetLastError());
906 msvcrt_set_errno(GetLastError());
907 ret = -1;
908 }
909 }
910 else
911 {
912 TRACE(":ok\n");
913 ret = 0;
914 }
915
916 release_ioinfo(info);
917 return ret;
918 }
919
920 /* flush_all_buffers calls MSVCRT_fflush which calls flush_all_buffers */
921 int CDECL MSVCRT_fflush(MSVCRT_FILE* file);
922
923 /* INTERNAL: Flush all stream buffer */
924 static int msvcrt_flush_all_buffers(int mask)
925 {
926 int i, num_flushed = 0;
927 MSVCRT_FILE *file;
928
929 LOCK_FILES();
930 for (i = 0; i < MSVCRT_stream_idx; i++) {
931 file = msvcrt_get_file(i);
932
933 if (file->_flag)
934 {
935 if(file->_flag & mask) {
936 MSVCRT_fflush(file);
937 num_flushed++;
938 }
939 }
940 }
941 UNLOCK_FILES();
942
943 TRACE(":flushed (%d) handles\n",num_flushed);
944 return num_flushed;
945 }
946
947 /*********************************************************************
948 * _flushall (MSVCRT.@)
949 */
950 int CDECL MSVCRT__flushall(void)
951 {
952 return msvcrt_flush_all_buffers(MSVCRT__IOWRT | MSVCRT__IOREAD);
953 }
954
955 /*********************************************************************
956 * fflush (MSVCRT.@)
957 */
958 int CDECL MSVCRT_fflush(MSVCRT_FILE* file)
959 {
960 int ret;
961
962 if(!file) {
963 msvcrt_flush_all_buffers(MSVCRT__IOWRT);
964 ret = 0;
965 } else {
966 MSVCRT__lock_file(file);
967 ret = MSVCRT__fflush_nolock(file);
968 MSVCRT__unlock_file(file);
969 }
970
971 return ret;
972 }
973
974 /*********************************************************************
975 * _fflush_nolock (MSVCRT.@)
976 */
977 int CDECL MSVCRT__fflush_nolock(MSVCRT_FILE* file)
978 {
979 int res;
980
981 if(!file) {
982 msvcrt_flush_all_buffers(MSVCRT__IOWRT);
983 return 0;
984 }
985
986 res = msvcrt_flush_buffer(file);
987 if(!res && (file->_flag & MSVCRT__IOCOMMIT))
988 res = MSVCRT__commit(file->_file) ? MSVCRT_EOF : 0;
989 return res;
990 }
991
992 /*********************************************************************
993 * _close (MSVCRT.@)
994 */
995 int CDECL MSVCRT__close(int fd)
996 {
997 ioinfo *info = get_ioinfo(fd);
998 int ret;
999
1000 LOCK_FILES();
1001 TRACE(":fd (%d) handle (%p)\n", fd, info->handle);
1002 if (!(info->wxflag & WX_OPEN)) {
1003 ret = -1;
1004 } else {
1005 ret = CloseHandle(info->handle) ? 0 : -1;
1006 msvcrt_free_fd(fd);
1007 if (ret) {
1008 WARN(":failed-last error (%d)\n",GetLastError());
1009 msvcrt_set_errno(GetLastError());
1010 }
1011 }
1012 UNLOCK_FILES();
1013 release_ioinfo(info);
1014 return ret;
1015 }
1016
1017 /*********************************************************************
1018 * _dup2 (MSVCRT.@)
1019 * NOTES
1020 * MSDN isn't clear on this point, but the remarks for _pipe
1021 * indicate file descriptors duplicated with _dup and _dup2 are always
1022 * inheritable.
1023 */
1024 int CDECL MSVCRT__dup2(int od, int nd)
1025 {
1026 ioinfo *info_od, *info_nd;
1027 int ret;
1028
1029 TRACE("(od=%d, nd=%d)\n", od, nd);
1030 LOCK_FILES();
1031
1032 if (od < nd)
1033 {
1034 info_od = get_ioinfo(od);
1035 info_nd = get_ioinfo(nd);
1036 }
1037 else
1038 {
1039 info_nd = get_ioinfo(nd);
1040 info_od = get_ioinfo(od);
1041 }
1042
1043 if (nd < MSVCRT_MAX_FILES && nd >= 0 && (info_od->wxflag & WX_OPEN))
1044 {
1045 HANDLE handle;
1046
1047 if (DuplicateHandle(GetCurrentProcess(), info_od->handle,
1048 GetCurrentProcess(), &handle, 0, TRUE, DUPLICATE_SAME_ACCESS))
1049 {
1050 int wxflag = info_od->wxflag & ~MSVCRT__O_NOINHERIT;
1051
1052 if (info_nd->wxflag & WX_OPEN)
1053 MSVCRT__close(nd);
1054 ret = msvcrt_set_fd(handle, wxflag, nd);
1055 if (ret == -1)
1056 {
1057 CloseHandle(handle);
1058 *MSVCRT__errno() = MSVCRT_EMFILE;
1059 }
1060 else
1061 {
1062 /* _dup2 returns 0, not nd, on success */
1063 ret = 0;
1064 }
1065 }
1066 else
1067 {
1068 ret = -1;
1069 msvcrt_set_errno(GetLastError());
1070 }
1071 }
1072 else
1073 {
1074 *MSVCRT__errno() = MSVCRT_EBADF;
1075 ret = -1;
1076 }
1077
1078 release_ioinfo(info_od);
1079 release_ioinfo(info_nd);
1080 UNLOCK_FILES();
1081 return ret;
1082 }
1083
1084 /*********************************************************************
1085 * _dup (MSVCRT.@)
1086 */
1087 int CDECL MSVCRT__dup(int od)
1088 {
1089 int fd, ret;
1090
1091 LOCK_FILES();
1092 fd = MSVCRT_fdstart;
1093 if (MSVCRT__dup2(od, fd) == 0)
1094 ret = fd;
1095 else
1096 ret = -1;
1097 UNLOCK_FILES();
1098 return ret;
1099 }
1100
1101 /*********************************************************************
1102 * _eof (MSVCRT.@)
1103 */
1104 int CDECL MSVCRT__eof(int fd)
1105 {
1106 ioinfo *info = get_ioinfo(fd);
1107 DWORD curpos,endpos;
1108 LONG hcurpos,hendpos;
1109
1110 TRACE(":fd (%d) handle (%p)\n", fd, info->handle);
1111
1112 if (info->handle == INVALID_HANDLE_VALUE)
1113 {
1114 release_ioinfo(info);
1115 return -1;
1116 }
1117
1118 if (info->wxflag & WX_ATEOF)
1119 {
1120 release_ioinfo(info);
1121 return TRUE;
1122 }
1123
1124 /* Otherwise we do it the hard way */
1125 hcurpos = hendpos = 0;
1126 curpos = SetFilePointer(info->handle, 0, &hcurpos, FILE_CURRENT);
1127 endpos = SetFilePointer(info->handle, 0, &hendpos, FILE_END);
1128
1129 if (curpos == endpos && hcurpos == hendpos)
1130 {
1131 /* FIXME: shouldn't WX_ATEOF be set here? */
1132 release_ioinfo(info);
1133 return TRUE;
1134 }
1135
1136 SetFilePointer(info->handle, curpos, &hcurpos, FILE_BEGIN);
1137 release_ioinfo(info);
1138 return FALSE;
1139 }
1140
1141 /*********************************************************************
1142 * _fcloseall (MSVCRT.@)
1143 */
1144 int CDECL MSVCRT__fcloseall(void)
1145 {
1146 int num_closed = 0, i;
1147 MSVCRT_FILE *file;
1148
1149 LOCK_FILES();
1150 for (i = 3; i < MSVCRT_stream_idx; i++) {
1151 file = msvcrt_get_file(i);
1152
1153 if (file->_flag && !MSVCRT_fclose(file))
1154 num_closed++;
1155 }
1156 UNLOCK_FILES();
1157
1158 TRACE(":closed (%d) handles\n",num_closed);
1159 return num_closed;
1160 }
1161
1162 /* free everything on process exit */
1163 void msvcrt_free_io(void)
1164 {
1165 unsigned int i;
1166 int j;
1167
1168 MSVCRT__flushall();
1169 MSVCRT__fcloseall();
1170
1171 for(i=0; i<sizeof(MSVCRT___pioinfo)/sizeof(MSVCRT___pioinfo[0]); i++)
1172 {
1173 if(!MSVCRT___pioinfo[i])
1174 continue;
1175
1176 for(j=0; j<MSVCRT_FD_BLOCK_SIZE; j++)
1177 {
1178 if(MSVCRT___pioinfo[i][j].exflag & EF_CRIT_INIT)
1179 DeleteCriticalSection(&MSVCRT___pioinfo[i][j].crit);
1180 }
1181 MSVCRT_free(MSVCRT___pioinfo[i]);
1182 }
1183
1184 for(j=0; j<MSVCRT_stream_idx; j++)
1185 {
1186 MSVCRT_FILE *file = msvcrt_get_file(j);
1187 if(file<MSVCRT__iob || file>=MSVCRT__iob+_IOB_ENTRIES)
1188 {
1189 ((file_crit*)file)->crit.DebugInfo->Spare[0] = 0;
1190 DeleteCriticalSection(&((file_crit*)file)->crit);
1191 }
1192 }
1193
1194 for(i=0; i<sizeof(MSVCRT_fstream)/sizeof(MSVCRT_fstream[0]); i++)
1195 MSVCRT_free(MSVCRT_fstream[i]);
1196
1197 DeleteCriticalSection(&MSVCRT_file_cs);
1198 }
1199
1200 /*********************************************************************
1201 * _lseeki64 (MSVCRT.@)
1202 */
1203 __int64 CDECL MSVCRT__lseeki64(int fd, __int64 offset, int whence)
1204 {
1205 ioinfo *info = get_ioinfo(fd);
1206 LARGE_INTEGER ofs;
1207
1208 TRACE(":fd (%d) handle (%p)\n", fd, info->handle);
1209
1210 if (info->handle == INVALID_HANDLE_VALUE)
1211 {
1212 release_ioinfo(info);
1213 return -1;
1214 }
1215
1216 if (whence < 0 || whence > 2)
1217 {
1218 release_ioinfo(info);
1219 *MSVCRT__errno() = MSVCRT_EINVAL;
1220 return -1;
1221 }
1222
1223 TRACE(":fd (%d) to %s pos %s\n",
1224 fd,wine_dbgstr_longlong(offset),
1225 (whence==SEEK_SET)?"SEEK_SET":
1226 (whence==SEEK_CUR)?"SEEK_CUR":
1227 (whence==SEEK_END)?"SEEK_END":"UNKNOWN");
1228
1229 /* The MoleBox protection scheme expects msvcrt to use SetFilePointer only,
1230 * so a LARGE_INTEGER offset cannot be passed directly via SetFilePointerEx. */
1231 ofs.QuadPart = offset;
1232 if ((ofs.u.LowPart = SetFilePointer(info->handle, ofs.u.LowPart, &ofs.u.HighPart, whence)) != INVALID_SET_FILE_POINTER ||
1233 GetLastError() == ERROR_SUCCESS)
1234 {
1235 info->wxflag &= ~WX_ATEOF;
1236 /* FIXME: What if we seek _to_ EOF - is EOF set? */
1237
1238 release_ioinfo(info);
1239 return ofs.QuadPart;
1240 }
1241 release_ioinfo(info);
1242 TRACE(":error-last error (%d)\n",GetLastError());
1243 msvcrt_set_errno(GetLastError());
1244 return -1;
1245 }
1246
1247 /*********************************************************************
1248 * _lseek (MSVCRT.@)
1249 */
1250 LONG CDECL MSVCRT__lseek(int fd, LONG offset, int whence)
1251 {
1252 return MSVCRT__lseeki64(fd, offset, whence);
1253 }
1254
1255 /*********************************************************************
1256 * _lock_file (MSVCRT.@)
1257 */
1258 void CDECL MSVCRT__lock_file(MSVCRT_FILE *file)
1259 {
1260 if(file>=MSVCRT__iob && file<MSVCRT__iob+_IOB_ENTRIES)
1261 _lock(_STREAM_LOCKS+(file-MSVCRT__iob));
1262 else
1263 EnterCriticalSection(&((file_crit*)file)->crit);
1264 }
1265
1266 /*********************************************************************
1267 * _unlock_file (MSVCRT.@)
1268 */
1269 void CDECL MSVCRT__unlock_file(MSVCRT_FILE *file)
1270 {
1271 if(file>=MSVCRT__iob && file<MSVCRT__iob+_IOB_ENTRIES)
1272 _unlock(_STREAM_LOCKS+(file-MSVCRT__iob));
1273 else
1274 LeaveCriticalSection(&((file_crit*)file)->crit);
1275 }
1276
1277 /*********************************************************************
1278 * _locking (MSVCRT.@)
1279 *
1280 * This is untested; the underlying LockFile doesn't work yet.
1281 */
1282 int CDECL MSVCRT__locking(int fd, int mode, LONG nbytes)
1283 {
1284 ioinfo *info = get_ioinfo(fd);
1285 BOOL ret;
1286 DWORD cur_locn;
1287
1288 TRACE(":fd (%d) handle (%p)\n", fd, info->handle);
1289 if (info->handle == INVALID_HANDLE_VALUE)
1290 {
1291 release_ioinfo(info);
1292 return -1;
1293 }
1294
1295 if (mode < 0 || mode > 4)
1296 {
1297 release_ioinfo(info);
1298 *MSVCRT__errno() = MSVCRT_EINVAL;
1299 return -1;
1300 }
1301
1302 TRACE(":fd (%d) by 0x%08x mode %s\n",
1303 fd,nbytes,(mode==MSVCRT__LK_UNLCK)?"_LK_UNLCK":
1304 (mode==MSVCRT__LK_LOCK)?"_LK_LOCK":
1305 (mode==MSVCRT__LK_NBLCK)?"_LK_NBLCK":
1306 (mode==MSVCRT__LK_RLCK)?"_LK_RLCK":
1307 (mode==MSVCRT__LK_NBRLCK)?"_LK_NBRLCK":
1308 "UNKNOWN");
1309
1310 if ((cur_locn = SetFilePointer(info->handle, 0L, NULL, SEEK_CUR)) == INVALID_SET_FILE_POINTER)
1311 {
1312 release_ioinfo(info);
1313 FIXME ("Seek failed\n");
1314 *MSVCRT__errno() = MSVCRT_EINVAL; /* FIXME */
1315 return -1;
1316 }
1317 if (mode == MSVCRT__LK_LOCK || mode == MSVCRT__LK_RLCK)
1318 {
1319 int nretry = 10;
1320 ret = 1; /* just to satisfy gcc */
1321 while (nretry--)
1322 {
1323 ret = LockFile(info->handle, cur_locn, 0L, nbytes, 0L);
1324 if (ret) break;
1325 Sleep(1);
1326 }
1327 }
1328 else if (mode == MSVCRT__LK_UNLCK)
1329 ret = UnlockFile(info->handle, cur_locn, 0L, nbytes, 0L);
1330 else
1331 ret = LockFile(info->handle, cur_locn, 0L, nbytes, 0L);
1332 /* FIXME - what about error settings? */
1333 release_ioinfo(info);
1334 return ret ? 0 : -1;
1335 }
1336
1337 /*********************************************************************
1338 * _fseeki64 (MSVCRT.@)
1339 */
1340 int CDECL MSVCRT__fseeki64(MSVCRT_FILE* file, __int64 offset, int whence)
1341 {
1342 int ret;
1343
1344 MSVCRT__lock_file(file);
1345 ret = MSVCRT__fseeki64_nolock(file, offset, whence);
1346 MSVCRT__unlock_file(file);
1347
1348 return ret;
1349 }
1350
1351 /*********************************************************************
1352 * _fseeki64_nolock (MSVCRT.@)
1353 */
1354 int CDECL MSVCRT__fseeki64_nolock(MSVCRT_FILE* file, __int64 offset, int whence)
1355 {
1356 int ret;
1357
1358 if(whence == SEEK_CUR && file->_flag & MSVCRT__IOREAD ) {
1359 whence = SEEK_SET;
1360 offset += MSVCRT__ftelli64_nolock(file);
1361 }
1362
1363 /* Flush output if needed */
1364 msvcrt_flush_buffer(file);
1365 /* Reset direction of i/o */
1366 if(file->_flag & MSVCRT__IORW) {
1367 file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
1368 }
1369 /* Clear end of file flag */
1370 file->_flag &= ~MSVCRT__IOEOF;
1371 ret = (MSVCRT__lseeki64(file->_file,offset,whence) == -1)?-1:0;
1372
1373 return ret;
1374 }
1375
1376 /*********************************************************************
1377 * fseek (MSVCRT.@)
1378 */
1379 int CDECL MSVCRT_fseek(MSVCRT_FILE* file, MSVCRT_long offset, int whence)
1380 {
1381 return MSVCRT__fseeki64( file, offset, whence );
1382 }
1383
1384 /*********************************************************************
1385 * _fseek_nolock (MSVCRT.@)
1386 */
1387 int CDECL MSVCRT__fseek_nolock(MSVCRT_FILE* file, MSVCRT_long offset, int whence)
1388 {
1389 return MSVCRT__fseeki64_nolock( file, offset, whence );
1390 }
1391
1392 /*********************************************************************
1393 * _chsize_s (MSVCRT.@)
1394 */
1395 int CDECL MSVCRT__chsize_s(int fd, __int64 size)
1396 {
1397 ioinfo *info;
1398 __int64 cur, pos;
1399 BOOL ret = FALSE;
1400
1401 TRACE("(fd=%d, size=%s)\n", fd, wine_dbgstr_longlong(size));
1402
1403 if (!MSVCRT_CHECK_PMT(size >= 0)) return MSVCRT_EINVAL;
1404
1405
1406 info = get_ioinfo(fd);
1407 if (info->handle != INVALID_HANDLE_VALUE)
1408 {
1409 /* save the current file pointer */
1410 cur = MSVCRT__lseeki64(fd, 0, SEEK_CUR);
1411 if (cur >= 0)
1412 {
1413 pos = MSVCRT__lseeki64(fd, size, SEEK_SET);
1414 if (pos >= 0)
1415 {
1416 ret = SetEndOfFile(info->handle);
1417 if (!ret) msvcrt_set_errno(GetLastError());
1418 }
1419
1420 /* restore the file pointer */
1421 MSVCRT__lseeki64(fd, cur, SEEK_SET);
1422 }
1423 }
1424
1425 release_ioinfo(info);
1426 return ret ? 0 : *MSVCRT__errno();
1427 }
1428
1429 /*********************************************************************
1430 * _chsize (MSVCRT.@)
1431 */
1432 int CDECL MSVCRT__chsize(int fd, MSVCRT_long size)
1433 {
1434 /* _chsize_s returns errno on failure but _chsize should return -1 */
1435 return MSVCRT__chsize_s( fd, size ) == 0 ? 0 : -1;
1436 }
1437
1438 /*********************************************************************
1439 * clearerr (MSVCRT.@)
1440 */
1441 void CDECL MSVCRT_clearerr(MSVCRT_FILE* file)
1442 {
1443 TRACE(":file (%p) fd (%d)\n",file,file->_file);
1444
1445 MSVCRT__lock_file(file);
1446 file->_flag &= ~(MSVCRT__IOERR | MSVCRT__IOEOF);
1447 MSVCRT__unlock_file(file);
1448 }
1449
1450 /*********************************************************************
1451 * rewind (MSVCRT.@)
1452 */
1453 void CDECL MSVCRT_rewind(MSVCRT_FILE* file)
1454 {
1455 TRACE(":file (%p) fd (%d)\n",file,file->_file);
1456
1457 MSVCRT__lock_file(file);
1458 MSVCRT__fseek_nolock(file, 0L, SEEK_SET);
1459 MSVCRT_clearerr(file);
1460 MSVCRT__unlock_file(file);
1461 }
1462
1463 static int msvcrt_get_flags(const MSVCRT_wchar_t* mode, int *open_flags, int* stream_flags)
1464 {
1465 int plus = strchrW(mode, '+') != NULL;
1466
1467 TRACE("%s\n", debugstr_w(mode));
1468
1469 while(*mode == ' ') mode++;
1470
1471 switch(*mode++)
1472 {
1473 case 'R': case 'r':
1474 *open_flags = plus ? MSVCRT__O_RDWR : MSVCRT__O_RDONLY;
1475 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOREAD;
1476 break;
1477 case 'W': case 'w':
1478 *open_flags = MSVCRT__O_CREAT | MSVCRT__O_TRUNC | (plus ? MSVCRT__O_RDWR : MSVCRT__O_WRONLY);
1479 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOWRT;
1480 break;
1481 case 'A': case 'a':
1482 *open_flags = MSVCRT__O_CREAT | MSVCRT__O_APPEND | (plus ? MSVCRT__O_RDWR : MSVCRT__O_WRONLY);
1483 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOWRT;
1484 break;
1485 default:
1486 MSVCRT_INVALID_PMT(0, MSVCRT_EINVAL);
1487 return -1;
1488 }
1489
1490 *stream_flags |= MSVCRT__commode;
1491
1492 while (*mode && *mode!=',')
1493 switch (*mode++)
1494 {
1495 case 'B': case 'b':
1496 *open_flags |= MSVCRT__O_BINARY;
1497 *open_flags &= ~MSVCRT__O_TEXT;
1498 break;
1499 case 't':
1500 *open_flags |= MSVCRT__O_TEXT;
1501 *open_flags &= ~MSVCRT__O_BINARY;
1502 break;
1503 case 'D':
1504 *open_flags |= MSVCRT__O_TEMPORARY;
1505 break;
1506 case 'T':
1507 *open_flags |= MSVCRT__O_SHORT_LIVED;
1508 break;
1509 case 'c':
1510 *stream_flags |= MSVCRT__IOCOMMIT;
1511 break;
1512 case 'n':
1513 *stream_flags &= ~MSVCRT__IOCOMMIT;
1514 break;
1515 case 'N':
1516 *open_flags |= MSVCRT__O_NOINHERIT;
1517 break;
1518 case '+':
1519 case ' ':
1520 case 'a':
1521 case 'w':
1522 break;
1523 case 'S':
1524 case 'R':
1525 FIXME("ignoring cache optimization flag: %c\n", mode[-1]);
1526 break;
1527 default:
1528 ERR("incorrect mode flag: %c\n", mode[-1]);
1529 break;
1530 }
1531
1532 if(*mode == ',')
1533 {
1534 static const WCHAR ccs[] = {'c','c','s'};
1535 static const WCHAR utf8[] = {'u','t','f','-','8'};
1536 static const WCHAR utf16le[] = {'u','t','f','-','1','6','l','e'};
1537 static const WCHAR unicode[] = {'u','n','i','c','o','d','e'};
1538
1539 mode++;
1540 while(*mode == ' ') mode++;
1541 if(!MSVCRT_CHECK_PMT(!strncmpW(ccs, mode, sizeof(ccs)/sizeof(ccs[0]))))
1542 return -1;
1543 mode += sizeof(ccs)/sizeof(ccs[0]);
1544 while(*mode == ' ') mode++;
1545 if(!MSVCRT_CHECK_PMT(*mode == '='))
1546 return -1;
1547 mode++;
1548 while(*mode == ' ') mode++;
1549
1550 if(!strncmpiW(utf8, mode, sizeof(utf8)/sizeof(utf8[0])))
1551 {
1552 *open_flags |= MSVCRT__O_U8TEXT;
1553 mode += sizeof(utf8)/sizeof(utf8[0]);
1554 }
1555 else if(!strncmpiW(utf16le, mode, sizeof(utf16le)/sizeof(utf16le[0])))
1556 {
1557 *open_flags |= MSVCRT__O_U16TEXT;
1558 mode += sizeof(utf16le)/sizeof(utf16le[0]);
1559 }
1560 else if(!strncmpiW(unicode, mode, sizeof(unicode)/sizeof(unicode[0])))
1561 {
1562 *open_flags |= MSVCRT__O_WTEXT;
1563 mode += sizeof(unicode)/sizeof(unicode[0]);
1564 }
1565 else
1566 {
1567 MSVCRT_INVALID_PMT(0, MSVCRT_EINVAL);
1568 return -1;
1569 }
1570
1571 while(*mode == ' ') mode++;
1572 }
1573
1574 if(!MSVCRT_CHECK_PMT(*mode == 0))
1575 return -1;
1576 return 0;
1577 }
1578
1579 /*********************************************************************
1580 * _fdopen (MSVCRT.@)
1581 */
1582 MSVCRT_FILE* CDECL MSVCRT__fdopen(int fd, const char *mode)
1583 {
1584 MSVCRT_FILE *ret;
1585 MSVCRT_wchar_t *modeW = NULL;
1586
1587 if (mode && !(modeW = msvcrt_wstrdupa(mode))) return NULL;
1588
1589 ret = MSVCRT__wfdopen(fd, modeW);
1590
1591 MSVCRT_free(modeW);
1592 return ret;
1593 }
1594
1595 /*********************************************************************
1596 * _wfdopen (MSVCRT.@)
1597 */
1598 MSVCRT_FILE* CDECL MSVCRT__wfdopen(int fd, const MSVCRT_wchar_t *mode)
1599 {
1600 int open_flags, stream_flags;
1601 MSVCRT_FILE* file;
1602
1603 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1) return NULL;
1604
1605 LOCK_FILES();
1606 if (!(file = msvcrt_alloc_fp()))
1607 file = NULL;
1608 else if (msvcrt_init_fp(file, fd, stream_flags) == -1)
1609 {
1610 file->_flag = 0;
1611 file = NULL;
1612 }
1613 else TRACE(":fd (%d) mode (%s) FILE* (%p)\n", fd, debugstr_w(mode), file);
1614 UNLOCK_FILES();
1615
1616 return file;
1617 }
1618
1619 /*********************************************************************
1620 * _filelength (MSVCRT.@)
1621 */
1622 LONG CDECL MSVCRT__filelength(int fd)
1623 {
1624 LONG curPos = MSVCRT__lseek(fd, 0, SEEK_CUR);
1625 if (curPos != -1)
1626 {
1627 LONG endPos = MSVCRT__lseek(fd, 0, SEEK_END);
1628 if (endPos != -1)
1629 {
1630 if (endPos != curPos)
1631 MSVCRT__lseek(fd, curPos, SEEK_SET);
1632 return endPos;
1633 }
1634 }
1635 return -1;
1636 }
1637
1638 /*********************************************************************
1639 * _filelengthi64 (MSVCRT.@)
1640 */
1641 __int64 CDECL MSVCRT__filelengthi64(int fd)
1642 {
1643 __int64 curPos = MSVCRT__lseeki64(fd, 0, SEEK_CUR);
1644 if (curPos != -1)
1645 {
1646 __int64 endPos = MSVCRT__lseeki64(fd, 0, SEEK_END);
1647 if (endPos != -1)
1648 {
1649 if (endPos != curPos)
1650 MSVCRT__lseeki64(fd, curPos, SEEK_SET);
1651 return endPos;
1652 }
1653 }
1654 return -1;
1655 }
1656
1657 /*********************************************************************
1658 * _fileno (MSVCRT.@)
1659 */
1660 int CDECL MSVCRT__fileno(MSVCRT_FILE* file)
1661 {
1662 TRACE(":FILE* (%p) fd (%d)\n",file,file->_file);
1663 return file->_file;
1664 }
1665
1666 /*********************************************************************
1667 * _fstat64 (MSVCRT.@)
1668 */
1669 int CDECL MSVCRT__fstat64(int fd, struct MSVCRT__stat64* buf)
1670 {
1671 ioinfo *info = get_ioinfo(fd);
1672 DWORD dw;
1673 DWORD type;
1674 BY_HANDLE_FILE_INFORMATION hfi;
1675
1676 TRACE(":fd (%d) stat (%p)\n", fd, buf);
1677 if (info->handle == INVALID_HANDLE_VALUE)
1678 {
1679 release_ioinfo(info);
1680 return -1;
1681 }
1682
1683 if (!buf)
1684 {
1685 WARN(":failed-NULL buf\n");
1686 msvcrt_set_errno(ERROR_INVALID_PARAMETER);
1687 release_ioinfo(info);
1688 return -1;
1689 }
1690
1691 memset(&hfi, 0, sizeof(hfi));
1692 memset(buf, 0, sizeof(struct MSVCRT__stat64));
1693 type = GetFileType(info->handle);
1694 if (type == FILE_TYPE_PIPE)
1695 {
1696 buf->st_dev = buf->st_rdev = fd;
1697 buf->st_mode = S_IFIFO;
1698 buf->st_nlink = 1;
1699 }
1700 else if (type == FILE_TYPE_CHAR)
1701 {
1702 buf->st_dev = buf->st_rdev = fd;
1703 buf->st_mode = S_IFCHR;
1704 buf->st_nlink = 1;
1705 }
1706 else /* FILE_TYPE_DISK etc. */
1707 {
1708 if (!GetFileInformationByHandle(info->handle, &hfi))
1709 {
1710 WARN(":failed-last error (%d)\n",GetLastError());
1711 msvcrt_set_errno(ERROR_INVALID_PARAMETER);
1712 release_ioinfo(info);
1713 return -1;
1714 }
1715 buf->st_mode = S_IFREG | 0444;
1716 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1717 buf->st_mode |= 0222;
1718 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
1719 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
1720 buf->st_atime = dw;
1721 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
1722 buf->st_mtime = buf->st_ctime = dw;
1723 buf->st_nlink = hfi.nNumberOfLinks;
1724 }
1725 TRACE(":dwFileAttributes = 0x%x, mode set to 0x%x\n",hfi.dwFileAttributes,
1726 buf->st_mode);
1727 release_ioinfo(info);
1728 return 0;
1729 }
1730
1731 /*********************************************************************
1732 * _fstati64 (MSVCRT.@)
1733 */
1734 int CDECL MSVCRT__fstati64(int fd, struct MSVCRT__stati64* buf)
1735 {
1736 int ret;
1737 struct MSVCRT__stat64 buf64;
1738
1739 ret = MSVCRT__fstat64(fd, &buf64);
1740 if (!ret)
1741 msvcrt_stat64_to_stati64(&buf64, buf);
1742 return ret;
1743 }
1744
1745 /*********************************************************************
1746 * _fstat (MSVCRT.@)
1747 */
1748 int CDECL MSVCRT__fstat(int fd, struct MSVCRT__stat* buf)
1749 { int ret;
1750 struct MSVCRT__stat64 buf64;
1751
1752 ret = MSVCRT__fstat64(fd, &buf64);
1753 if (!ret)
1754 msvcrt_stat64_to_stat(&buf64, buf);
1755 return ret;
1756 }
1757
1758 /*********************************************************************
1759 * _fstat32 (MSVCR80.@)
1760 */
1761 int CDECL MSVCRT__fstat32(int fd, struct MSVCRT__stat32* buf)
1762 {
1763 int ret;
1764 struct MSVCRT__stat64 buf64;
1765
1766 ret = MSVCRT__fstat64(fd, &buf64);
1767 if (!ret)
1768 msvcrt_stat64_to_stat32(&buf64, buf);
1769 return ret;
1770 }
1771
1772 /*********************************************************************
1773 * _fstat64i32 (MSVCR80.@)
1774 */
1775 int CDECL MSVCRT__fstat64i32(int fd, struct MSVCRT__stat64i32* buf)
1776 {
1777 int ret;
1778 struct MSVCRT__stat64 buf64;
1779
1780 ret = MSVCRT__fstat64(fd, &buf64);
1781 if (!ret)
1782 msvcrt_stat64_to_stat64i32(&buf64, buf);
1783 return ret;
1784 }
1785
1786 /*********************************************************************
1787 * _futime64 (MSVCRT.@)
1788 */
1789 int CDECL _futime64(int fd, struct MSVCRT___utimbuf64 *t)
1790 {
1791 ioinfo *info = get_ioinfo(fd);
1792 FILETIME at, wt;
1793
1794 if (!t)
1795 {
1796 time_to_filetime( MSVCRT__time64(NULL), &at );
1797 wt = at;
1798 }
1799 else
1800 {
1801 time_to_filetime( t->actime, &at );
1802 time_to_filetime( t->modtime, &wt );
1803 }
1804
1805 if (!SetFileTime(info->handle, NULL, &at, &wt))
1806 {
1807 release_ioinfo(info);
1808 msvcrt_set_errno(GetLastError());
1809 return -1 ;
1810 }
1811 release_ioinfo(info);
1812 return 0;
1813 }
1814
1815 /*********************************************************************
1816 * _futime32 (MSVCRT.@)
1817 */
1818 int CDECL _futime32(int fd, struct MSVCRT___utimbuf32 *t)
1819 {
1820 if (t)
1821 {
1822 struct MSVCRT___utimbuf64 t64;
1823 t64.actime = t->actime;
1824 t64.modtime = t->modtime;
1825 return _futime64( fd, &t64 );
1826 }
1827 else
1828 return _futime64( fd, NULL );
1829 }
1830
1831 /*********************************************************************
1832 * _futime (MSVCRT.@)
1833 */
1834 #ifdef _WIN64
1835 int CDECL _futime(int fd, struct MSVCRT___utimbuf64 *t)
1836 {
1837 return _futime64( fd, t );
1838 }
1839 #else
1840 int CDECL _futime(int fd, struct MSVCRT___utimbuf32 *t)
1841 {
1842 return _futime32( fd, t );
1843 }
1844 #endif
1845
1846 /*********************************************************************
1847 * _get_osfhandle (MSVCRT.@)
1848 */
1849 MSVCRT_intptr_t CDECL MSVCRT__get_osfhandle(int fd)
1850 {
1851 HANDLE hand = msvcrt_fdtoh(fd);
1852 TRACE(":fd (%d) handle (%p)\n",fd,hand);
1853
1854 return (MSVCRT_intptr_t)hand;
1855 }
1856
1857 /*********************************************************************
1858 * _mktemp_s (MSVCRT.@)
1859 */
1860 int CDECL MSVCRT__mktemp_s(char *pattern, MSVCRT_size_t size)
1861 {
1862 DWORD len, xno, id;
1863
1864 if(!MSVCRT_CHECK_PMT(pattern!=NULL))
1865 return MSVCRT_EINVAL;
1866
1867 for(len=0; len<size; len++)
1868 if(!pattern[len])
1869 break;
1870 if(!MSVCRT_CHECK_PMT(len!=size && len>=6)) {
1871 if(size)
1872 pattern[0] = 0;
1873 return MSVCRT_EINVAL;
1874 }
1875
1876 for(xno=1; xno<=6; xno++)
1877 if(!MSVCRT_CHECK_PMT(pattern[len-xno] == 'X'))
1878 return MSVCRT_EINVAL;
1879
1880 id = GetCurrentProcessId();
1881 for(xno=1; xno<6; xno++) {
1882 pattern[len-xno] = id%10 + '0';
1883 id /= 10;
1884 }
1885
1886 for(pattern[len-6]='a'; pattern[len-6]<='z'; pattern[len-6]++) {
1887 if(GetFileAttributesA(pattern) == INVALID_FILE_ATTRIBUTES)
1888 return 0;
1889 }
1890
1891 pattern[0] = 0;
1892 *MSVCRT__errno() = MSVCRT_EEXIST;
1893 return MSVCRT_EEXIST;
1894 }
1895
1896 /*********************************************************************
1897 * _mktemp (MSVCRT.@)
1898 */
1899 char * CDECL MSVCRT__mktemp(char *pattern)
1900 {
1901 int numX = 0;
1902 char *retVal = pattern;
1903 int id;
1904 char letter = 'a';
1905
1906 if(!pattern)
1907 return NULL;
1908
1909 while(*pattern)
1910 numX = (*pattern++ == 'X')? numX + 1 : 0;
1911 if (numX < 6)
1912 return NULL;
1913 pattern--;
1914 id = GetCurrentProcessId();
1915 numX = 6;
1916 while(numX--)
1917 {
1918 int tempNum = id / 10;
1919 *pattern-- = id - (tempNum * 10) + '0';
1920 id = tempNum;
1921 }
1922 pattern++;
1923 do
1924 {
1925 *pattern = letter++;
1926 if (GetFileAttributesA(retVal) == INVALID_FILE_ATTRIBUTES)
1927 return retVal;
1928 } while(letter <= 'z');
1929 return NULL;
1930 }
1931
1932 /*********************************************************************
1933 * _wmktemp_s (MSVCRT.@)
1934 */
1935 int CDECL MSVCRT__wmktemp_s(MSVCRT_wchar_t *pattern, MSVCRT_size_t size)
1936 {
1937 DWORD len, xno, id;
1938
1939 if(!MSVCRT_CHECK_PMT(pattern!=NULL))
1940 return MSVCRT_EINVAL;
1941
1942 for(len=0; len<size; len++)
1943 if(!pattern[len])
1944 break;
1945 if(!MSVCRT_CHECK_PMT(len!=size && len>=6)) {
1946 if(size)
1947 pattern[0] = 0;
1948 return MSVCRT_EINVAL;
1949 }
1950
1951 for(xno=1; xno<=6; xno++)
1952 if(!MSVCRT_CHECK_PMT(pattern[len-xno] == 'X'))
1953 return MSVCRT_EINVAL;
1954
1955 id = GetCurrentProcessId();
1956 for(xno=1; xno<6; xno++) {
1957 pattern[len-xno] = id%10 + '0';
1958 id /= 10;
1959 }
1960
1961 for(pattern[len-6]='a'; pattern[len-6]<='z'; pattern[len-6]++) {
1962 if(GetFileAttributesW(pattern) == INVALID_FILE_ATTRIBUTES)
1963 return 0;
1964 }
1965
1966 pattern[0] = 0;
1967 *MSVCRT__errno() = MSVCRT_EEXIST;
1968 return MSVCRT_EEXIST;
1969 }
1970
1971 /*********************************************************************
1972 * _wmktemp (MSVCRT.@)
1973 */
1974 MSVCRT_wchar_t * CDECL MSVCRT__wmktemp(MSVCRT_wchar_t *pattern)
1975 {
1976 int numX = 0;
1977 MSVCRT_wchar_t *retVal = pattern;
1978 int id;
1979 MSVCRT_wchar_t letter = 'a';
1980
1981 if(!pattern)
1982 return NULL;
1983
1984 while(*pattern)
1985 numX = (*pattern++ == 'X')? numX + 1 : 0;
1986 if (numX < 6)
1987 return NULL;
1988 pattern--;
1989 id = GetCurrentProcessId();
1990 numX = 6;
1991 while(numX--)
1992 {
1993 int tempNum = id / 10;
1994 *pattern-- = id - (tempNum * 10) + '0';
1995 id = tempNum;
1996 }
1997 pattern++;
1998 do
1999 {
2000 if (GetFileAttributesW(retVal) == INVALID_FILE_ATTRIBUTES)
2001 return retVal;
2002 *pattern = letter++;
2003 } while(letter != '|');
2004 return NULL;
2005 }
2006
2007 static unsigned split_oflags(unsigned oflags)
2008 {
2009 int wxflags = 0;
2010 unsigned unsupp; /* until we support everything */
2011
2012 if (oflags & MSVCRT__O_APPEND) wxflags |= WX_APPEND;
2013 if (oflags & MSVCRT__O_BINARY) {/* Nothing to do */}
2014 else if (oflags & MSVCRT__O_TEXT) wxflags |= WX_TEXT;
2015 else if (oflags & MSVCRT__O_WTEXT) wxflags |= WX_TEXT;
2016 else if (oflags & MSVCRT__O_U16TEXT) wxflags |= WX_TEXT;
2017 else if (oflags & MSVCRT__O_U8TEXT) wxflags |= WX_TEXT;
2018 else if (*__p__fmode() & MSVCRT__O_BINARY) {/* Nothing to do */}
2019 else wxflags |= WX_TEXT; /* default to TEXT*/
2020 if (oflags & MSVCRT__O_NOINHERIT) wxflags |= WX_DONTINHERIT;
2021
2022 if ((unsupp = oflags & ~(
2023 MSVCRT__O_BINARY|MSVCRT__O_TEXT|MSVCRT__O_APPEND|
2024 MSVCRT__O_TRUNC|MSVCRT__O_EXCL|MSVCRT__O_CREAT|
2025 MSVCRT__O_RDWR|MSVCRT__O_WRONLY|MSVCRT__O_TEMPORARY|
2026 MSVCRT__O_NOINHERIT|
2027 MSVCRT__O_SEQUENTIAL|MSVCRT__O_RANDOM|MSVCRT__O_SHORT_LIVED|
2028 MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT
2029 )))
2030 ERR(":unsupported oflags 0x%04x\n",unsupp);
2031
2032 return wxflags;
2033 }
2034
2035 /*********************************************************************
2036 * _pipe (MSVCRT.@)
2037 */
2038 int CDECL MSVCRT__pipe(int *pfds, unsigned int psize, int textmode)
2039 {
2040 int ret = -1;
2041 SECURITY_ATTRIBUTES sa;
2042 HANDLE readHandle, writeHandle;
2043
2044 if (!pfds)
2045 {
2046 *MSVCRT__errno() = MSVCRT_EINVAL;
2047 return -1;
2048 }
2049
2050 sa.nLength = sizeof(SECURITY_ATTRIBUTES);
2051 sa.bInheritHandle = !(textmode & MSVCRT__O_NOINHERIT);
2052 sa.lpSecurityDescriptor = NULL;
2053 if (CreatePipe(&readHandle, &writeHandle, &sa, psize))
2054 {
2055 unsigned int wxflags = split_oflags(textmode);
2056 int fd;
2057
2058 LOCK_FILES();
2059 fd = msvcrt_alloc_fd(readHandle, wxflags|WX_PIPE);
2060 if (fd != -1)
2061 {
2062 pfds[0] = fd;
2063 fd = msvcrt_alloc_fd(writeHandle, wxflags|WX_PIPE);
2064 if (fd != -1)
2065 {
2066 pfds[1] = fd;
2067 ret = 0;
2068 }
2069 else
2070 {
2071 MSVCRT__close(pfds[0]);
2072 CloseHandle(writeHandle);
2073 *MSVCRT__errno() = MSVCRT_EMFILE;
2074 }
2075 }
2076 else
2077 {
2078 CloseHandle(readHandle);
2079 CloseHandle(writeHandle);
2080 *MSVCRT__errno() = MSVCRT_EMFILE;
2081 }
2082 UNLOCK_FILES();
2083 }
2084 else
2085 msvcrt_set_errno(GetLastError());
2086
2087 return ret;
2088 }
2089
2090 static int check_bom(HANDLE h, int oflags, BOOL seek)
2091 {
2092 char bom[sizeof(utf8_bom)];
2093 DWORD r;
2094
2095 oflags &= ~(MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT);
2096
2097 if (!ReadFile(h, bom, sizeof(utf8_bom), &r, NULL))
2098 return oflags;
2099
2100 if (r==sizeof(utf8_bom) && !memcmp(bom, utf8_bom, sizeof(utf8_bom))) {
2101 oflags |= MSVCRT__O_U8TEXT;
2102 }else if (r>=sizeof(utf16_bom) && !memcmp(bom, utf16_bom, sizeof(utf16_bom))) {
2103 if (seek && r>2)
2104 SetFilePointer(h, 2, NULL, FILE_BEGIN);
2105 oflags |= MSVCRT__O_U16TEXT;
2106 }else if (seek) {
2107 SetFilePointer(h, 0, NULL, FILE_BEGIN);
2108 }
2109
2110 return oflags;
2111 }
2112
2113 /*********************************************************************
2114 * _wsopen_s (MSVCRT.@)
2115 */
2116 int CDECL MSVCRT__wsopen_s( int *fd, const MSVCRT_wchar_t* path, int oflags, int shflags, int pmode )
2117 {
2118 DWORD access = 0, creation = 0, attrib;
2119 SECURITY_ATTRIBUTES sa;
2120 DWORD sharing, type;
2121 int wxflag;
2122 HANDLE hand;
2123
2124 TRACE("fd*: %p :file (%s) oflags: 0x%04x shflags: 0x%04x pmode: 0x%04x\n",
2125 fd, debugstr_w(path), oflags, shflags, pmode);
2126
2127 if (!MSVCRT_CHECK_PMT( fd != NULL )) return MSVCRT_EINVAL;
2128
2129 *fd = -1;
2130 wxflag = split_oflags(oflags);
2131 switch (oflags & (MSVCRT__O_RDONLY | MSVCRT__O_WRONLY | MSVCRT__O_RDWR))
2132 {
2133 case MSVCRT__O_RDONLY: access |= GENERIC_READ; break;
2134 case MSVCRT__O_WRONLY: access |= GENERIC_WRITE; break;
2135 case MSVCRT__O_RDWR: access |= GENERIC_WRITE | GENERIC_READ; break;
2136 }
2137
2138 if (oflags & MSVCRT__O_CREAT)
2139 {
2140 if(pmode & ~(MSVCRT__S_IREAD | MSVCRT__S_IWRITE))
2141 FIXME(": pmode 0x%04x ignored\n", pmode);
2142
2143 if (oflags & MSVCRT__O_EXCL)
2144 creation = CREATE_NEW;
2145 else if (oflags & MSVCRT__O_TRUNC)
2146 creation = CREATE_ALWAYS;
2147 else
2148 creation = OPEN_ALWAYS;
2149 }
2150 else /* no MSVCRT__O_CREAT */
2151 {
2152 if (oflags & MSVCRT__O_TRUNC)
2153 creation = TRUNCATE_EXISTING;
2154 else
2155 creation = OPEN_EXISTING;
2156 }
2157
2158 switch( shflags )
2159 {
2160 case MSVCRT__SH_DENYRW:
2161 sharing = 0L;
2162 break;
2163 case MSVCRT__SH_DENYWR:
2164 sharing = FILE_SHARE_READ;
2165 break;
2166 case MSVCRT__SH_DENYRD:
2167 sharing = FILE_SHARE_WRITE;
2168 break;
2169 case MSVCRT__SH_DENYNO:
2170 sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
2171 break;
2172 default:
2173 ERR( "Unhandled shflags 0x%x\n", shflags );
2174 return MSVCRT_EINVAL;
2175 }
2176
2177 if (!(pmode & ~MSVCRT_umask & MSVCRT__S_IWRITE))
2178 attrib = FILE_ATTRIBUTE_READONLY;
2179 else
2180 attrib = FILE_ATTRIBUTE_NORMAL;
2181
2182 if (oflags & MSVCRT__O_TEMPORARY)
2183 {
2184 attrib |= FILE_FLAG_DELETE_ON_CLOSE;
2185 access |= DELETE;
2186 sharing |= FILE_SHARE_DELETE;
2187 }
2188
2189 sa.nLength = sizeof( SECURITY_ATTRIBUTES );
2190 sa.lpSecurityDescriptor = NULL;
2191 sa.bInheritHandle = !(oflags & MSVCRT__O_NOINHERIT);
2192
2193 if ((oflags&(MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT))
2194 && (creation==OPEN_ALWAYS || creation==OPEN_EXISTING)
2195 && !(access&GENERIC_READ))
2196 {
2197 hand = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE,
2198 &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
2199 if (hand != INVALID_HANDLE_VALUE)
2200 {
2201 oflags = check_bom(hand, oflags, FALSE);
2202 CloseHandle(hand);
2203 }
2204 else
2205 oflags &= ~(MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT);
2206 }
2207
2208 hand = CreateFileW(path, access, sharing, &sa, creation, attrib, 0);
2209 if (hand == INVALID_HANDLE_VALUE) {
2210 WARN(":failed-last error (%d)\n",GetLastError());
2211 msvcrt_set_errno(GetLastError());
2212 return *MSVCRT__errno();
2213 }
2214
2215 if (oflags & (MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT))
2216 {
2217 if ((access & GENERIC_WRITE) && (creation==CREATE_NEW
2218 || creation==CREATE_ALWAYS || creation==TRUNCATE_EXISTING
2219 || (creation==OPEN_ALWAYS && GetLastError()==ERROR_ALREADY_EXISTS)))
2220 {
2221 if (oflags & MSVCRT__O_U8TEXT)
2222 {
2223 DWORD written = 0, tmp;
2224
2225 while(written!=sizeof(utf8_bom) && WriteFile(hand, (char*)utf8_bom+written,
2226 sizeof(utf8_bom)-written, &tmp, NULL))
2227 written += tmp;
2228 if (written != sizeof(utf8_bom)) {
2229 WARN("error writing BOM\n");
2230 CloseHandle(hand);
2231 msvcrt_set_errno(GetLastError());
2232 return *MSVCRT__errno();
2233 }
2234 }
2235 else
2236 {
2237 DWORD written = 0, tmp;
2238
2239 while(written!=sizeof(utf16_bom) && WriteFile(hand, (char*)utf16_bom+written,
2240 sizeof(utf16_bom)-written, &tmp, NULL))
2241 written += tmp;
2242 if (written != sizeof(utf16_bom))
2243 {
2244 WARN("error writing BOM\n");
2245 CloseHandle(hand);
2246 msvcrt_set_errno(GetLastError());
2247 return *MSVCRT__errno();
2248 }
2249 }
2250 }
2251 else if (access & GENERIC_READ)
2252 oflags = check_bom(hand, oflags, TRUE);
2253 }
2254
2255 type = GetFileType(hand);
2256 if (type == FILE_TYPE_CHAR)
2257 wxflag |= WX_TTY;
2258 else if (type == FILE_TYPE_PIPE)
2259 wxflag |= WX_PIPE;
2260
2261 *fd = msvcrt_alloc_fd(hand, wxflag);
2262 if (*fd == -1)
2263 return *MSVCRT__errno();
2264
2265 if (oflags & MSVCRT__O_WTEXT)
2266 get_ioinfo_nolock(*fd)->exflag |= EF_UTF16|EF_UNK_UNICODE;
2267 else if (oflags & MSVCRT__O_U16TEXT)
2268 get_ioinfo_nolock(*fd)->exflag |= EF_UTF16;
2269 else if (oflags & MSVCRT__O_U8TEXT)
2270 get_ioinfo_nolock(*fd)->exflag |= EF_UTF8;
2271
2272 TRACE(":fd (%d) handle (%p)\n", *fd, hand);
2273 return 0;
2274 }
2275
2276 /*********************************************************************
2277 * _wsopen (MSVCRT.@)
2278 */
2279 int CDECL MSVCRT__wsopen( const MSVCRT_wchar_t *path, int oflags, int shflags, ... )
2280 {
2281 int pmode;
2282 int fd;
2283
2284 if (oflags & MSVCRT__O_CREAT)
2285 {
2286 __ms_va_list ap;
2287
2288 __ms_va_start(ap, shflags);
2289 pmode = va_arg(ap, int);
2290 __ms_va_end(ap);
2291 }
2292 else
2293 pmode = 0;
2294
2295 MSVCRT__wsopen_s(&fd, path, oflags, shflags, pmode);
2296 return fd;
2297 }
2298
2299 /*********************************************************************
2300 * _sopen_s (MSVCRT.@)
2301 */
2302 int CDECL MSVCRT__sopen_s( int *fd, const char *path, int oflags, int shflags, int pmode )
2303 {
2304 MSVCRT_wchar_t *pathW;
2305 int ret;
2306
2307 if (!MSVCRT_CHECK_PMT(fd != NULL))
2308 return MSVCRT_EINVAL;
2309 *fd = -1;
2310 if(!MSVCRT_CHECK_PMT(path && (pathW = msvcrt_wstrdupa(path))))
2311 return MSVCRT_EINVAL;
2312
2313 ret = MSVCRT__wsopen_s(fd, pathW, oflags, shflags, pmode);
2314 MSVCRT_free(pathW);
2315 return ret;
2316 }
2317
2318 /*********************************************************************
2319 * _sopen (MSVCRT.@)
2320 */
2321 int CDECL MSVCRT__sopen( const char *path, int oflags, int shflags, ... )
2322 {
2323 int pmode;
2324 int fd;
2325
2326 if (oflags & MSVCRT__O_CREAT)
2327 {
2328 __ms_va_list ap;
2329
2330 __ms_va_start(ap, shflags);
2331 pmode = va_arg(ap, int);
2332 __ms_va_end(ap);
2333 }
2334 else
2335 pmode = 0;
2336
2337 MSVCRT__sopen_s(&fd, path, oflags, shflags, pmode);
2338 return fd;
2339 }
2340
2341 /*********************************************************************
2342 * _open (MSVCRT.@)
2343 */
2344 int CDECL MSVCRT__open( const char *path, int flags, ... )
2345 {
2346 __ms_va_list ap;
2347
2348 if (flags & MSVCRT__O_CREAT)
2349 {
2350 int pmode;
2351 __ms_va_start(ap, flags);
2352 pmode = va_arg(ap, int);
2353 __ms_va_end(ap);
2354 return MSVCRT__sopen( path, flags, MSVCRT__SH_DENYNO, pmode );
2355 }
2356 else
2357 return MSVCRT__sopen( path, flags, MSVCRT__SH_DENYNO);
2358 }
2359
2360 /*********************************************************************
2361 * _wopen (MSVCRT.@)
2362 */
2363 int CDECL MSVCRT__wopen(const MSVCRT_wchar_t *path,int flags,...)
2364 {
2365 __ms_va_list ap;
2366
2367 if (flags & MSVCRT__O_CREAT)
2368 {
2369 int pmode;
2370 __ms_va_start(ap, flags);
2371 pmode = va_arg(ap, int);
2372 __ms_va_end(ap);
2373 return MSVCRT__wsopen( path, flags, MSVCRT__SH_DENYNO, pmode );
2374 }
2375 else
2376 return MSVCRT__wsopen( path, flags, MSVCRT__SH_DENYNO);
2377 }
2378
2379 /*********************************************************************
2380 * _creat (MSVCRT.@)
2381 */
2382 int CDECL MSVCRT__creat(const char *path, int flags)
2383 {
2384 int usedFlags = (flags & MSVCRT__O_TEXT)| MSVCRT__O_CREAT| MSVCRT__O_WRONLY| MSVCRT__O_TRUNC;
2385 return MSVCRT__open(path, usedFlags);
2386 }
2387
2388 /*********************************************************************
2389 * _wcreat (MSVCRT.@)
2390 */
2391 int CDECL MSVCRT__wcreat(const MSVCRT_wchar_t *path, int flags)
2392 {
2393 int usedFlags = (flags & MSVCRT__O_TEXT)| MSVCRT__O_CREAT| MSVCRT__O_WRONLY| MSVCRT__O_TRUNC;
2394 return MSVCRT__wopen(path, usedFlags);
2395 }
2396
2397 /*********************************************************************
2398 * _open_osfhandle (MSVCRT.@)
2399 */
2400 int CDECL MSVCRT__open_osfhandle(MSVCRT_intptr_t handle, int oflags)
2401 {
2402 DWORD flags;
2403 int fd;
2404
2405 /* MSVCRT__O_RDONLY (0) always matches, so set the read flag
2406 * MFC's CStdioFile clears O_RDONLY (0)! if it wants to write to the
2407 * file, so set the write flag. It also only sets MSVCRT__O_TEXT if it wants
2408 * text - it never sets MSVCRT__O_BINARY.
2409 */
2410 /* don't let split_oflags() decide the mode if no mode is passed */
2411 if (!(oflags & (MSVCRT__O_BINARY | MSVCRT__O_TEXT)))
2412 oflags |= MSVCRT__O_BINARY;
2413
2414 flags = GetFileType((HANDLE)handle);
2415 if (flags==FILE_TYPE_UNKNOWN && GetLastError()!=NO_ERROR)
2416 {
2417 msvcrt_set_errno(GetLastError());
2418 return -1;
2419 }
2420
2421 if (flags == FILE_TYPE_CHAR)
2422 flags = WX_TTY;
2423 else if (flags == FILE_TYPE_PIPE)
2424 flags = WX_PIPE;
2425 else
2426 flags = 0;
2427 flags |= split_oflags(oflags);
2428
2429 fd = msvcrt_alloc_fd((HANDLE)handle, flags);
2430 TRACE(":handle (%ld) fd (%d) flags 0x%08x\n", handle, fd, flags);
2431 return fd;
2432 }
2433
2434 /*********************************************************************
2435 * _rmtmp (MSVCRT.@)
2436 */
2437 int CDECL MSVCRT__rmtmp(void)
2438 {
2439 int num_removed = 0, i;
2440 MSVCRT_FILE *file;
2441
2442 LOCK_FILES();
2443 for (i = 3; i < MSVCRT_stream_idx; i++) {
2444 file = msvcrt_get_file(i);
2445
2446 if (file->_tmpfname)
2447 {
2448 MSVCRT_fclose(file);
2449 num_removed++;
2450 }
2451 }
2452 UNLOCK_FILES();
2453
2454 if (num_removed)
2455 TRACE(":removed (%d) temp files\n",num_removed);
2456 return num_removed;
2457 }
2458
2459 static inline int get_utf8_char_len(char ch)
2460 {
2461 if((ch&0xf8) == 0xf0)
2462 return 4;
2463 else if((ch&0xf0) == 0xe0)
2464 return 3;
2465 else if((ch&0xe0) == 0xc0)
2466 return 2;
2467 return 1;
2468 }
2469
2470 /*********************************************************************
2471 * (internal) read_utf8
2472 */
2473 static int read_utf8(ioinfo *fdinfo, MSVCRT_wchar_t *buf, unsigned int count)
2474 {
2475 HANDLE hand = fdinfo->handle;
2476 char min_buf[4], *readbuf, lookahead;
2477 DWORD readbuf_size, pos=0, num_read=1, char_len, i, j;
2478
2479 /* make the buffer big enough to hold at least one character */
2480 /* read bytes have to fit to output and lookahead buffers */
2481 count /= 2;
2482 readbuf_size = count < 4 ? 4 : count;
2483 if(readbuf_size<=4 || !(readbuf = MSVCRT_malloc(readbuf_size))) {
2484 readbuf_size = 4;
2485 readbuf = min_buf;
2486 }
2487
2488 if(fdinfo->lookahead[0] != '\n') {
2489 readbuf[pos++] = fdinfo->lookahead[0];
2490 fdinfo->lookahead[0] = '\n';
2491
2492 if(fdinfo->lookahead[1] != '\n') {
2493 readbuf[pos++] = fdinfo->lookahead[1];
2494 fdinfo->lookahead[1] = '\n';
2495
2496 if(fdinfo->lookahead[2] != '\n') {
2497 readbuf[pos++] = fdinfo->lookahead[2];
2498 fdinfo->lookahead[2] = '\n';
2499 }
2500 }
2501 }
2502
2503 /* NOTE: this case is broken in native dll, reading
2504 * sometimes fails when small buffer is passed
2505 */
2506 if(count < 4) {
2507 if(!pos && !ReadFile(hand, readbuf, 1, &num_read, NULL)) {
2508 if (GetLastError() == ERROR_BROKEN_PIPE) {
2509 fdinfo->wxflag |= WX_ATEOF;
2510 return 0;
2511 }else {
2512 msvcrt_set_errno(GetLastError());
2513 return -1;
2514 }
2515 }else if(!num_read) {
2516 fdinfo->wxflag |= WX_ATEOF;
2517 return 0;
2518 }else {
2519 pos++;
2520 }
2521
2522 char_len = get_utf8_char_len(readbuf[0]);
2523 if(char_len>pos) {
2524 if(ReadFile(hand, readbuf+pos, char_len-pos, &num_read, NULL))
2525 pos += num_read;
2526 }
2527
2528 if(readbuf[0] == '\n')
2529 fdinfo->wxflag |= WX_READNL;
2530 else
2531 fdinfo->wxflag &= ~WX_READNL;
2532
2533 if(readbuf[0] == 0x1a) {
2534 fdinfo->wxflag |= WX_ATEOF;
2535 return 0;
2536 }
2537
2538 if(readbuf[0] == '\r') {
2539 if(!ReadFile(hand, &lookahead, 1, &num_read, NULL) || num_read!=1)
2540 buf[0] = '\r';
2541 else if(lookahead == '\n')
2542 buf[0] = '\n';
2543 else {
2544 buf[0] = '\r';
2545 if(fdinfo->wxflag & (WX_PIPE | WX_TTY))
2546 fdinfo->lookahead[0] = lookahead;
2547 else
2548 SetFilePointer(fdinfo->handle, -1, NULL, FILE_CURRENT);
2549 }
2550 return 2;
2551 }
2552
2553 if(!(num_read = MultiByteToWideChar(CP_UTF8, 0, readbuf, pos, buf, count))) {
2554 msvcrt_set_errno(GetLastError());
2555 return -1;
2556 }
2557
2558 return num_read*2;
2559 }
2560
2561 if(!ReadFile(hand, readbuf+pos, readbuf_size-pos, &num_read, NULL)) {
2562 if(pos) {
2563 num_read = 0;
2564 }else if(GetLastError() == ERROR_BROKEN_PIPE) {
2565 fdinfo->wxflag |= WX_ATEOF;
2566 if (readbuf != min_buf) MSVCRT_free(readbuf);
2567 return 0;
2568 }else {
2569 msvcrt_set_errno(GetLastError());
2570 if (readbuf != min_buf) MSVCRT_free(readbuf);
2571 return -1;
2572 }
2573 }else if(!pos && !num_read) {
2574 fdinfo->wxflag |= WX_ATEOF;
2575 if (readbuf != min_buf) MSVCRT_free(readbuf);
2576 return 0;
2577 }
2578
2579 pos += num_read;
2580 if(readbuf[0] == '\n')
2581 fdinfo->wxflag |= WX_READNL;
2582 else
2583 fdinfo->wxflag &= ~WX_READNL;
2584
2585 /* Find first byte of last character (may be incomplete) */
2586 for(i=pos-1; i>0 && i>pos-4; i--)
2587 if((readbuf[i]&0xc0) != 0x80)
2588 break;
2589 char_len = get_utf8_char_len(readbuf[i]);
2590 if(char_len+i <= pos)
2591 i += char_len;
2592
2593 if(fdinfo->wxflag & (WX_PIPE | WX_TTY)) {
2594 if(i < pos)
2595 fdinfo->lookahead[0] = readbuf[i];
2596 if(i+1 < pos)
2597 fdinfo->lookahead[1] = readbuf[i+1];
2598 if(i+2 < pos)
2599 fdinfo->lookahead[2] = readbuf[i+2];
2600 }else if(i < pos) {
2601 SetFilePointer(fdinfo->handle, i-pos, NULL, FILE_CURRENT);
2602 }
2603 pos = i;
2604
2605 for(i=0, j=0; i<pos; i++) {
2606 if(readbuf[i] == 0x1a) {
2607 fdinfo->wxflag |= WX_ATEOF;
2608 break;
2609 }
2610
2611 /* strip '\r' if followed by '\n' */
2612 if(readbuf[i] == '\r' && i+1==pos) {
2613 if(fdinfo->lookahead[0] != '\n' || !ReadFile(hand, &lookahead, 1, &num_read, NULL) || !num_read) {
2614 readbuf[j++] = '\r';
2615 }else if(lookahead == '\n' && j==0) {
2616 readbuf[j++] = '\n';
2617 }else {
2618 if(lookahead != '\n')
2619 readbuf[j++] = '\r';
2620
2621 if(fdinfo->wxflag & (WX_PIPE | WX_TTY))
2622 fdinfo->lookahead[0] = lookahead;
2623 else
2624 SetFilePointer(fdinfo->handle, -1, NULL, FILE_CURRENT);
2625 }
2626 }else if(readbuf[i]!='\r' || readbuf[i+1]!='\n') {
2627 readbuf[j++] = readbuf[i];
2628 }
2629 }
2630 pos = j;
2631
2632 if(!(num_read = MultiByteToWideChar(CP_UTF8, 0, readbuf, pos, buf, count))) {
2633 msvcrt_set_errno(GetLastError());
2634 if (readbuf != min_buf) MSVCRT_free(readbuf);
2635 return -1;
2636 }
2637
2638 if (readbuf != min_buf) MSVCRT_free(readbuf);
2639 return num_read*2;
2640 }
2641
2642 /*********************************************************************
2643 * (internal) read_i
2644 *
2645 * When reading \r as last character in text mode, read() positions
2646 * the file pointer on the \r character while getc() goes on to
2647 * the following \n
2648 */
2649 static int read_i(int fd, ioinfo *fdinfo, void *buf, unsigned int count)
2650 {
2651 DWORD num_read, utf16;
2652 char *bufstart = buf;
2653
2654 if (count == 0)
2655 return 0;
2656
2657 if (fdinfo->wxflag & WX_ATEOF) {
2658 TRACE("already at EOF, returning 0\n");
2659 return 0;
2660 }
2661 /* Don't trace small reads, it gets *very* annoying */
2662 if (count > 4)
2663 TRACE(":fd (%d) handle (%p) buf (%p) len (%d)\n", fd, fdinfo->handle, buf, count);
2664 if (fdinfo->handle == INVALID_HANDLE_VALUE)
2665 {
2666 *MSVCRT__errno() = MSVCRT_EBADF;
2667 return -1;
2668 }
2669
2670 utf16 = (fdinfo->exflag & EF_UTF16) != 0;
2671 if (((fdinfo->exflag&EF_UTF8) || utf16) && count&1)
2672 {
2673 *MSVCRT__errno() = MSVCRT_EINVAL;
2674 return -1;
2675 }
2676
2677 if((fdinfo->wxflag&WX_TEXT) && (fdinfo->exflag&EF_UTF8))
2678 return read_utf8(fdinfo, buf, count);
2679
2680 if (fdinfo->lookahead[0]!='\n' || ReadFile(fdinfo->handle, bufstart, count, &num_read, NULL))
2681 {
2682 if (fdinfo->lookahead[0] != '\n')
2683 {
2684 bufstart[0] = fdinfo->lookahead[0];
2685 fdinfo->lookahead[0] = '\n';
2686
2687 if (utf16)
2688 {
2689 bufstart[1] = fdinfo->lookahead[1];
2690 fdinfo->lookahead[1] = '\n';
2691 }
2692
2693 if(count>1+utf16 && ReadFile(fdinfo->handle, bufstart+1+utf16, count-1-utf16, &num_read, NULL))
2694 num_read += 1+utf16;
2695 else
2696 num_read = 1+utf16;
2697 }
2698
2699 if(utf16 && (num_read&1))
2700 {
2701 /* msvcr90 uses uninitialized value from the buffer in this case */
2702 /* msvcrt ignores additional data */
2703 ERR("got odd number of bytes in UTF16 mode\n");
2704 num_read--;
2705 }
2706
2707 if (count != 0 && num_read == 0)
2708 {
2709 fdinfo->wxflag |= WX_ATEOF;
2710 TRACE(":EOF %s\n",debugstr_an(buf,num_read));
2711 }
2712 else if (fdinfo->wxflag & WX_TEXT)
2713 {
2714 DWORD i, j;
2715
2716 if (bufstart[0]=='\n' && (!utf16 || bufstart[1]==0))
2717 fdinfo->wxflag |= WX_READNL;
2718 else
2719 fdinfo->wxflag &= ~WX_READNL;
2720
2721 for (i=0, j=0; i<num_read; i+=1+utf16)
2722 {
2723 /* in text mode, a ctrl-z signals EOF */
2724 if (bufstart[i]==0x1a && (!utf16 || bufstart[i+1]==0))
2725 {
2726 fdinfo->wxflag |= WX_ATEOF;
2727 TRACE(":^Z EOF %s\n",debugstr_an(buf,num_read));
2728 break;
2729 }
2730
2731 /* in text mode, strip \r if followed by \n */
2732 if (bufstart[i]=='\r' && (!utf16 || bufstart[i+1]==0) && i+1+utf16==num_read)
2733 {
2734 char lookahead[2];
2735 DWORD len;
2736
2737 lookahead[1] = '\n';
2738 if (ReadFile(fdinfo->handle, lookahead, 1+utf16, &len, NULL) && len)
2739 {
2740 if(lookahead[0]=='\n' && (!utf16 || lookahead[1]==0) && j==0)
2741 {
2742 bufstart[j++] = '\n';
2743 if(utf16) bufstart[j++] = 0;
2744 }
2745 else
2746 {
2747 if(lookahead[0]!='\n' || (utf16 && lookahead[1]!=0))
2748 {
2749 bufstart[j++] = '\r';
2750 if(utf16) bufstart[j++] = 0;
2751 }
2752
2753 if (fdinfo->wxflag & (WX_PIPE | WX_TTY))
2754 {
2755 if (lookahead[0]=='\n' && (!utf16 || !lookahead[1]))
2756 {
2757 bufstart[j++] = '\n';
2758 if (utf16) bufstart[j++] = 0;
2759 }
2760 else
2761 {
2762 fdinfo->lookahead[0] = lookahead[0];
2763 fdinfo->lookahead[1] = lookahead[1];
2764 }
2765 }
2766 else
2767 SetFilePointer(fdinfo->handle, -1-utf16, NULL, FILE_CURRENT);
2768 }
2769 }
2770 else
2771 {
2772 bufstart[j++] = '\r';
2773 if(utf16) bufstart[j++] = 0;
2774 }
2775 }
2776 else if((bufstart[i]!='\r' || (utf16 && bufstart[i+1]!=0))
2777 || (bufstart[i+1+utf16]!='\n' || (utf16 && bufstart[i+3]!=0)))
2778 {
2779 bufstart[j++] = bufstart[i];
2780 if(utf16) bufstart[j++] = bufstart[i+1];
2781 }
2782 }
2783 num_read = j;
2784 }
2785 }
2786 else
2787 {
2788 if (GetLastError() == ERROR_BROKEN_PIPE)
2789 {
2790 TRACE(":end-of-pipe\n");
2791 fdinfo->wxflag |= WX_ATEOF;
2792 return 0;
2793 }
2794 else
2795 {
2796 TRACE(":failed-last error (%d)\n",GetLastError());
2797 return -1;
2798 }
2799 }
2800
2801 if (count > 4)
2802 TRACE("(%u), %s\n",num_read,debugstr_an(buf, num_read));
2803 return num_read;
2804 }
2805
2806 /*********************************************************************
2807 * _read (MSVCRT.@)
2808 */
2809 int CDECL MSVCRT__read(int fd, void *buf, unsigned int count)
2810 {
2811 ioinfo *info = get_ioinfo(fd);
2812 int num_read = read_i(fd, info, buf, count);
2813 release_ioinfo(info);
2814 return num_read;
2815 }
2816
2817 /*********************************************************************
2818 * _setmode (MSVCRT.@)
2819 */
2820 int CDECL MSVCRT__setmode(int fd,int mode)
2821 {
2822 int ret = get_ioinfo_nolock(fd)->wxflag & WX_TEXT ? MSVCRT__O_TEXT : MSVCRT__O_BINARY;
2823 if(ret==MSVCRT__O_TEXT && (get_ioinfo_nolock(fd)->exflag & (EF_UTF8|EF_UTF16)))
2824 ret = MSVCRT__O_WTEXT;
2825
2826 if(mode!=MSVCRT__O_TEXT && mode!=MSVCRT__O_BINARY && mode!=MSVCRT__O_WTEXT
2827 && mode!=MSVCRT__O_U16TEXT && mode!=MSVCRT__O_U8TEXT) {
2828 *MSVCRT__errno() = MSVCRT_EINVAL;
2829 return -1;
2830 }
2831
2832 if(mode == MSVCRT__O_BINARY) {
2833 get_ioinfo_nolock(fd)->wxflag &= ~WX_TEXT;
2834 get_ioinfo_nolock(fd)->exflag &= ~(EF_UTF8|EF_UTF16);
2835 return ret;
2836 }
2837
2838 get_ioinfo_nolock(fd)->wxflag |= WX_TEXT;
2839 if(mode == MSVCRT__O_TEXT)
2840 get_ioinfo_nolock(fd)->exflag &= ~(EF_UTF8|EF_UTF16);
2841 else if(mode == MSVCRT__O_U8TEXT)
2842 get_ioinfo_nolock(fd)->exflag = (get_ioinfo_nolock(fd)->exflag & ~EF_UTF16) | EF_UTF8;
2843 else
2844 get_ioinfo_nolock(fd)->exflag = (get_ioinfo_nolock(fd)->exflag & ~EF_UTF8) | EF_UTF16;
2845
2846 return ret;
2847 }
2848
2849 /*********************************************************************
2850 * _stat64 (MSVCRT.@)
2851 */
2852 int CDECL MSVCRT_stat64(const char* path, struct MSVCRT__stat64 * buf)
2853 {
2854 DWORD dw;
2855 WIN32_FILE_ATTRIBUTE_DATA hfi;
2856 unsigned short mode = ALL_S_IREAD;
2857 int plen;
2858
2859 TRACE(":file (%s) buf(%p)\n",path,buf);
2860
2861 plen = strlen(path);
2862 while (plen && path[plen-1]==' ')
2863 plen--;
2864
2865 if (plen && (plen<2 || path[plen-2]!=':') &&
2866 (path[plen-1]==':' || path[plen-1]=='\\' || path[plen-1]=='/'))
2867 {
2868 *MSVCRT__errno() = MSVCRT_ENOENT;
2869 return -1;
2870 }
2871
2872 if (!GetFileAttributesExA(path, GetFileExInfoStandard, &hfi))
2873 {
2874 TRACE("failed (%d)\n",GetLastError());
2875 *MSVCRT__errno() = MSVCRT_ENOENT;
2876 return -1;
2877 }
2878
2879 memset(buf,0,sizeof(struct MSVCRT__stat64));
2880
2881 /* FIXME: rdev isn't drive num, despite what the docs say-what is it?
2882 Bon 011120: This FIXME seems incorrect
2883 Also a letter as first char isn't enough to be classified
2884 as a drive letter
2885 */
2886 if (isalpha(*path)&& (*(path+1)==':'))
2887 buf->st_dev = buf->st_rdev = toupper(*path) - 'A'; /* drive num */
2888 else
2889 buf->st_dev = buf->st_rdev = MSVCRT__getdrive() - 1;
2890
2891 /* Dir, or regular file? */
2892 if (hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2893 mode |= (MSVCRT__S_IFDIR | ALL_S_IEXEC);
2894 else
2895 {
2896 mode |= MSVCRT__S_IFREG;
2897 /* executable? */
2898 if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
2899 {
2900 unsigned int ext = tolower(path[plen-1]) | (tolower(path[plen-2]) << 8) |
2901 (tolower(path[plen-3]) << 16);
2902 if (ext == EXE || ext == BAT || ext == CMD || ext == COM)
2903 mode |= ALL_S_IEXEC;
2904 }
2905 }
2906
2907 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
2908 mode |= ALL_S_IWRITE;
2909
2910 buf->st_mode = mode;
2911 buf->st_nlink = 1;
2912 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
2913 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
2914 buf->st_atime = dw;
2915 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
2916 buf->st_mtime = buf->st_ctime = dw;
2917 TRACE("%d %d 0x%08x%08x %d %d %d\n", buf->st_mode,buf->st_nlink,
2918 (int)(buf->st_size >> 32),(int)buf->st_size,
2919 (int)buf->st_atime,(int)buf->st_mtime,(int)buf->st_ctime);
2920 return 0;
2921 }
2922
2923 /*********************************************************************
2924 * _stati64 (MSVCRT.@)
2925 */
2926 int CDECL MSVCRT_stati64(const char* path, struct MSVCRT__stati64 * buf)
2927 {
2928 int ret;
2929 struct MSVCRT__stat64 buf64;
2930
2931 ret = MSVCRT_stat64(path, &buf64);
2932 if (!ret)
2933 msvcrt_stat64_to_stati64(&buf64, buf);
2934 return ret;
2935 }
2936
2937 /*********************************************************************
2938 * _stat (MSVCRT.@)
2939 */
2940 int CDECL MSVCRT_stat(const char* path, struct MSVCRT__stat * buf)
2941 {
2942 int ret;
2943 struct MSVCRT__stat64 buf64;
2944
2945 ret = MSVCRT_stat64( path, &buf64);
2946 if (!ret)
2947 msvcrt_stat64_to_stat(&buf64, buf);
2948 return ret;
2949 }
2950
2951 /*********************************************************************
2952 * _stat32 (MSVCR100.@)
2953 */
2954 int CDECL MSVCRT__stat32(const char *path, struct MSVCRT__stat32 *buf)
2955 {
2956 int ret;
2957 struct MSVCRT__stat64 buf64;
2958
2959 ret = MSVCRT_stat64(path, &buf64);
2960 if (!ret)
2961 msvcrt_stat64_to_stat32(&buf64, buf);
2962 return ret;
2963 }
2964
2965 /*********************************************************************
2966 * _stat32i64 (MSVCR100.@)
2967 */
2968 int CDECL MSVCRT__stat32i64(const char *path, struct MSVCRT__stat32i64 *buf)
2969 {
2970 int ret;
2971 struct MSVCRT__stat64 buf64;
2972
2973 ret = MSVCRT_stat64(path, &buf64);
2974 if (!ret)
2975 msvcrt_stat64_to_stat32i64(&buf64, buf);
2976 return ret;
2977 }
2978
2979 /*********************************************************************
2980 * _stat64i32 (MSVCR100.@)
2981 */
2982 int CDECL MSVCRT__stat64i32(const char* path, struct MSVCRT__stat64i32 *buf)
2983 {
2984 int ret;
2985 struct MSVCRT__stat64 buf64;
2986
2987 ret = MSVCRT_stat64(path, &buf64);
2988 if (!ret)
2989 msvcrt_stat64_to_stat64i32(&buf64, buf);
2990 return ret;
2991 }
2992
2993 /*********************************************************************
2994 * _wstat64 (MSVCRT.@)
2995 */
2996 int CDECL MSVCRT__wstat64(const MSVCRT_wchar_t* path, struct MSVCRT__stat64 * buf)
2997 {
2998 DWORD dw;
2999 WIN32_FILE_ATTRIBUTE_DATA hfi;
3000 unsigned short mode = ALL_S_IREAD;
3001 int plen;
3002
3003 TRACE(":file (%s) buf(%p)\n",debugstr_w(path),buf);
3004
3005 plen = strlenW(path);
3006 while (plen && path[plen-1]==' ')
3007 plen--;
3008
3009 if(plen && (plen<2 || path[plen-2]!=':') &&
3010 (path[plen-1]==':' || path[plen-1]=='\\' || path[plen-1]=='/'))
3011 {
3012 *MSVCRT__errno() = MSVCRT_ENOENT;
3013 return -1;
3014 }
3015
3016 if (!GetFileAttributesExW(path, GetFileExInfoStandard, &hfi))
3017 {
3018 TRACE("failed (%d)\n",GetLastError());
3019 *MSVCRT__errno() = MSVCRT_ENOENT;
3020 return -1;
3021 }
3022
3023 memset(buf,0,sizeof(struct MSVCRT__stat64));
3024
3025 /* FIXME: rdev isn't drive num, despite what the docs says-what is it? */
3026 if (MSVCRT_iswalpha(*path))
3027 buf->st_dev = buf->st_rdev = toupperW(*path - 'A'); /* drive num */
3028 else
3029 buf->st_dev = buf->st_rdev = MSVCRT__getdrive() - 1;
3030
3031 /* Dir, or regular file? */
3032 if (hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
3033 mode |= (MSVCRT__S_IFDIR | ALL_S_IEXEC);
3034 else
3035 {
3036 mode |= MSVCRT__S_IFREG;
3037 /* executable? */
3038 if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
3039 {
3040 ULONGLONG ext = tolowerW(path[plen-1]) | (tolowerW(path[plen-2]) << 16) |
3041 ((ULONGLONG)tolowerW(path[plen-3]) << 32);
3042 if (ext == WCEXE || ext == WCBAT || ext == WCCMD || ext == WCCOM)
3043 mode |= ALL_S_IEXEC;
3044 }
3045 }
3046
3047 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
3048 mode |= ALL_S_IWRITE;
3049
3050 buf->st_mode = mode;
3051 buf->st_nlink = 1;
3052 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
3053 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
3054 buf->st_atime = dw;
3055 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
3056 buf->st_mtime = buf->st_ctime = dw;
3057 TRACE("%d %d 0x%08x%08x %d %d %d\n", buf->st_mode,buf->st_nlink,
3058 (int)(buf->st_size >> 32),(int)buf->st_size,
3059 (int)buf->st_atime,(int)buf->st_mtime,(int)buf->st_ctime);
3060 return 0;
3061 }
3062
3063 /*********************************************************************
3064 * _wstati64 (MSVCRT.@)
3065 */
3066 int CDECL MSVCRT__wstati64(const MSVCRT_wchar_t* path, struct MSVCRT__stati64 * buf)
3067 {
3068 int ret;
3069 struct MSVCRT__stat64 buf64;
3070
3071 ret = MSVCRT__wstat64(path, &buf64);
3072 if (!ret)
3073 msvcrt_stat64_to_stati64(&buf64, buf);
3074 return ret;
3075 }
3076
3077 /*********************************************************************
3078 * _wstat (MSVCRT.@)
3079 */
3080 int CDECL MSVCRT__wstat(const MSVCRT_wchar_t* path, struct MSVCRT__stat * buf)
3081 {
3082 int ret;
3083 struct MSVCRT__stat64 buf64;
3084
3085 ret = MSVCRT__wstat64( path, &buf64 );
3086 if (!ret) msvcrt_stat64_to_stat(&buf64, buf);
3087 return ret;
3088 }
3089
3090 /*********************************************************************
3091 * _wstat32 (MSVCR100.@)
3092 */
3093 int CDECL MSVCRT__wstat32(const MSVCRT_wchar_t *path, struct MSVCRT__stat32 *buf)
3094 {
3095 int ret;
3096 struct MSVCRT__stat64 buf64;
3097
3098 ret = MSVCRT__wstat64(path, &buf64);
3099 if (!ret)
3100 msvcrt_stat64_to_stat32(&buf64, buf);
3101 return ret;
3102 }
3103
3104 /*********************************************************************
3105 * _wstat32i64 (MSVCR100.@)
3106 */
3107 int CDECL MSVCRT__wstat32i64(const MSVCRT_wchar_t *path, struct MSVCRT__stat32i64 *buf)
3108 {
3109 int ret;
3110 struct MSVCRT__stat64 buf64;
3111
3112 ret = MSVCRT__wstat64(path, &buf64);
3113 if (!ret)
3114 msvcrt_stat64_to_stat32i64(&buf64, buf);
3115 return ret;
3116 }
3117
3118 /*********************************************************************
3119 * _wstat64i32 (MSVCR100.@)
3120 */
3121 int CDECL MSVCRT__wstat64i32(const MSVCRT_wchar_t *path, struct MSVCRT__stat64i32 *buf)
3122 {
3123 int ret;
3124 struct MSVCRT__stat64 buf64;
3125
3126 ret = MSVCRT__wstat64(path, &buf64);
3127 if (!ret)
3128 msvcrt_stat64_to_stat64i32(&buf64, buf);
3129 return ret;
3130 }
3131
3132 /*********************************************************************
3133 * _tell (MSVCRT.@)
3134 */
3135 MSVCRT_long CDECL MSVCRT__tell(int fd)
3136 {
3137 return MSVCRT__lseek(fd, 0, SEEK_CUR);
3138 }
3139
3140 /*********************************************************************
3141 * _telli64 (MSVCRT.@)
3142 */
3143 __int64 CDECL _telli64(int fd)
3144 {
3145 return MSVCRT__lseeki64(fd, 0, SEEK_CUR);
3146 }
3147
3148 /*********************************************************************
3149 * _tempnam (MSVCRT.@)
3150 */
3151 char * CDECL MSVCRT__tempnam(const char *dir, const char *prefix)
3152 {
3153 char tmpbuf[MAX_PATH];
3154 const char *tmp_dir = MSVCRT_getenv("TMP");
3155
3156 if (tmp_dir) dir = tmp_dir;
3157
3158 TRACE("dir (%s) prefix (%s)\n",dir,prefix);
3159 if (GetTempFileNameA(dir,prefix,0,tmpbuf))
3160 {
3161 TRACE("got name (%s)\n",tmpbuf);
3162 DeleteFileA(tmpbuf);
3163 return MSVCRT__strdup(tmpbuf);
3164 }
3165 TRACE("failed (%d)\n",GetLastError());
3166 return NULL;
3167 }
3168
3169 /*********************************************************************
3170 * _wtempnam (MSVCRT.@)
3171 */
3172 MSVCRT_wchar_t * CDECL MSVCRT__wtempnam(const MSVCRT_wchar_t *dir, const MSVCRT_wchar_t *prefix)
3173 {
3174 static const MSVCRT_wchar_t tmpW[] = {'T','M','P',0};
3175 MSVCRT_wchar_t tmpbuf[MAX_PATH];
3176 const MSVCRT_wchar_t *tmp_dir = MSVCRT__wgetenv(tmpW);
3177
3178 if (tmp_dir) dir = tmp_dir;
3179
3180 TRACE("dir (%s) prefix (%s)\n",debugstr_w(dir),debugstr_w(prefix));
3181 if (GetTempFileNameW(dir,prefix,0,tmpbuf))
3182 {
3183 TRACE("got name (%s)\n",debugstr_w(tmpbuf));
3184 DeleteFileW(tmpbuf);
3185 return MSVCRT__wcsdup(tmpbuf);
3186 }
3187 TRACE("failed (%d)\n",GetLastError());
3188 return NULL;
3189 }
3190
3191 /*********************************************************************
3192 * _umask (MSVCRT.@)
3193 */
3194 int CDECL MSVCRT__umask(int umask)
3195 {
3196 int old_umask = MSVCRT_umask;
3197 TRACE("(%d)\n",umask);
3198 MSVCRT_umask = umask;
3199 return old_umask;
3200 }
3201
3202 /*********************************************************************
3203 * _utime64 (MSVCRT.@)
3204 */
3205 int CDECL _utime64(const char* path, struct MSVCRT___utimbuf64 *t)
3206 {
3207 int fd = MSVCRT__open(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
3208
3209 if (fd > 0)
3210 {
3211 int retVal = _futime64(fd, t);
3212 MSVCRT__close(fd);
3213 return retVal;
3214 }
3215 return -1;
3216 }
3217
3218 /*********************************************************************
3219 * _utime32 (MSVCRT.@)
3220 */
3221 int CDECL _utime32(const char* path, struct MSVCRT___utimbuf32 *t)
3222 {
3223 if (t)
3224 {
3225 struct MSVCRT___utimbuf64 t64;
3226 t64.actime = t->actime;
3227 t64.modtime = t->modtime;
3228 return _utime64( path, &t64 );
3229 }
3230 else
3231 return _utime64( path, NULL );
3232 }
3233
3234 /*********************************************************************
3235 * _utime (MSVCRT.@)
3236 */
3237 #ifdef _WIN64
3238 int CDECL _utime(const char* path, struct MSVCRT___utimbuf64 *t)
3239 {
3240 return _utime64( path, t );
3241 }
3242 #else
3243 int CDECL _utime(const char* path, struct MSVCRT___utimbuf32 *t)
3244 {
3245 return _utime32( path, t );
3246 }
3247 #endif
3248
3249 /*********************************************************************
3250 * _wutime64 (MSVCRT.@)
3251 */
3252 int CDECL _wutime64(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf64 *t)
3253 {
3254 int fd = MSVCRT__wopen(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
3255
3256 if (fd > 0)
3257 {
3258 int retVal = _futime64(fd, t);
3259 MSVCRT__close(fd);
3260 return retVal;
3261 }
3262 return -1;
3263 }
3264
3265 /*********************************************************************
3266 * _wutime32 (MSVCRT.@)
3267 */
3268 int CDECL _wutime32(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf32 *t)
3269 {
3270 if (t)
3271 {
3272 struct MSVCRT___utimbuf64 t64;
3273 t64.actime = t->actime;
3274 t64.modtime = t->modtime;
3275 return _wutime64( path, &t64 );
3276 }
3277 else
3278 return _wutime64( path, NULL );
3279 }
3280
3281 /*********************************************************************
3282 * _wutime (MSVCRT.@)
3283 */
3284 #ifdef _WIN64
3285 int CDECL _wutime(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf64 *t)
3286 {
3287 return _wutime64( path, t );
3288 }
3289 #else
3290 int CDECL _wutime(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf32 *t)
3291 {
3292 return _wutime32( path, t );
3293 }
3294 #endif
3295
3296 /*********************************************************************
3297 * _write (MSVCRT.@)
3298 */
3299 int CDECL MSVCRT__write(int fd, const void* buf, unsigned int count)
3300 {
3301 DWORD num_written;
3302 ioinfo *info = get_ioinfo_nolock(fd);
3303 HANDLE hand = info->handle;
3304
3305 /* Don't trace small writes, it gets *very* annoying */
3306 #if 0
3307 if (count > 32)
3308 TRACE(":fd (%d) handle (%d) buf (%p) len (%d)\n",fd,hand,buf,count);
3309 #endif
3310 if (hand == INVALID_HANDLE_VALUE)
3311 {
3312 *MSVCRT__errno() = MSVCRT_EBADF;
3313 return -1;
3314 }
3315
3316 if (((info->exflag&EF_UTF8) || (info->exflag&EF_UTF16)) && count&1)
3317 {
3318 *MSVCRT__errno() = MSVCRT_EINVAL;
3319 return -1;
3320 }
3321
3322 /* If appending, go to EOF */
3323 if (info->wxflag & WX_APPEND)
3324 MSVCRT__lseek(fd, 0, FILE_END);
3325
3326 if (!(info->wxflag & WX_TEXT))
3327 {
3328 if (WriteFile(hand, buf, count, &num_written, NULL)
3329 && (num_written == count))
3330 return num_written;
3331 TRACE("WriteFile (fd %d, hand %p) failed-last error (%d)\n", fd,
3332 hand, GetLastError());
3333 *MSVCRT__errno() = MSVCRT_ENOSPC;
3334 }
3335 else
3336 {
3337 unsigned int i, j, nr_lf, size;
3338 char *p = NULL;
3339 const char *q;
3340 const char *s = buf, *buf_start = buf;
3341
3342 if (!(info->exflag & (EF_UTF8|EF_UTF16)))
3343 {
3344 /* find number of \n */
3345 for (nr_lf=0, i=0; i<count; i++)
3346 if (s[i] == '\n')
3347 nr_lf++;
3348 if (nr_lf)
3349 {
3350 size = count+nr_lf;
3351 if ((q = p = MSVCRT_malloc(size)))
3352 {
3353 for (s = buf, i = 0, j = 0; i < count; i++)
3354 {
3355 if (s[i] == '\n')
3356 p[j++] = '\r';
3357 p[j++] = s[i];
3358 }
3359 }
3360 else
3361 {
3362 FIXME("Malloc failed\n");
3363 nr_lf = 0;
3364 size = count;
3365 q = buf;
3366 }
3367 }
3368 else
3369 {
3370 size = count;
3371 q = buf;
3372 }
3373 }
3374 else if (info->exflag & EF_UTF16)
3375 {
3376 for (nr_lf=0, i=0; i<count; i+=2)
3377 if (s[i]=='\n' && s[i+1]==0)
3378 nr_lf += 2;
3379 if (nr_lf)
3380 {
3381 size = count+nr_lf;
3382 if ((q = p = MSVCRT_malloc(size)))
3383 {
3384 for (s=buf, i=0, j=0; i<count; i++)
3385 {
3386 if (s[i]=='\n' && s[i+1]==0)
3387 {
3388 p[j++] = '\r';
3389 p[j++] = 0;
3390 }
3391 p[j++] = s[i++];
3392 p[j++] = s[i];
3393 }
3394 }
3395 else
3396 {
3397 FIXME("Malloc failed\n");
3398 nr_lf = 0;
3399 size = count;
3400 q = buf;
3401 }
3402 }
3403 else
3404 {
3405 size = count;
3406 q = buf;
3407 }
3408 }
3409 else
3410 {
3411 DWORD conv_len;
3412
3413 for(nr_lf=0, i=0; i<count; i+=2)
3414 if (s[i]=='\n' && s[i+1]==0)
3415 nr_lf++;
3416
3417 conv_len = WideCharToMultiByte(CP_UTF8, 0, (WCHAR*)buf, count/2, NULL, 0, NULL, NULL);
3418 if(!conv_len) {
3419 msvcrt_set_errno(GetLastError());
3420 MSVCRT_free(p);
3421 return -1;
3422 }
3423
3424 size = conv_len+nr_lf;
3425 if((p = MSVCRT_malloc(count+nr_lf*2+size)))
3426 {
3427 for (s=buf, i=0, j=0; i<count; i++)
3428 {
3429 if (s[i]=='\n' && s[i+1]==0)
3430 {
3431 p[j++] = '\r';
3432 p[j++] = 0;
3433 }
3434 p[j++] = s[i++];
3435 p[j++] = s[i];
3436 }
3437 q = p+count+nr_lf*2;
3438 WideCharToMultiByte(CP_UTF8, 0, (WCHAR*)p, count/2+nr_lf,
3439 p+count+nr_lf*2, conv_len+nr_lf, NULL, NULL);
3440 }
3441 else
3442 {
3443 FIXME("Malloc failed\n");
3444 nr_lf = 0;
3445 size = count;
3446 q = buf;
3447 }
3448 }
3449
3450 if (!WriteFile(hand, q, size, &num_written, NULL))
3451 num_written = -1;
3452 if(p)
3453 MSVCRT_free(p);
3454 if (num_written != size)
3455 {
3456 TRACE("WriteFile (fd %d, hand %p) failed-last error (%d), num_written %d\n",
3457 fd, hand, GetLastError(), num_written);
3458 *MSVCRT__errno() = MSVCRT_ENOSPC;
3459 return s - buf_start;
3460 }
3461 return count;
3462 }
3463
3464 return -1;
3465 }
3466
3467 /*********************************************************************
3468 * _putw (MSVCRT.@)
3469 */
3470 int CDECL MSVCRT__putw(int val, MSVCRT_FILE* file)
3471 {
3472 int len;
3473
3474 MSVCRT__lock_file(file);
3475 len = MSVCRT__write(file->_file, &val, sizeof(val));
3476 if (len == sizeof(val)) {
3477 MSVCRT__unlock_file(file);
3478 return val;
3479 }
3480
3481 file->_flag |= MSVCRT__IOERR;
3482 MSVCRT__unlock_file(file);
3483 return MSVCRT_EOF;
3484 }
3485
3486 /*********************************************************************
3487 * fclose (MSVCRT.@)
3488 */
3489 int CDECL MSVCRT_fclose(MSVCRT_FILE* file)
3490 {
3491 int ret;
3492
3493 MSVCRT__lock_file(file);
3494 ret = MSVCRT__fclose_nolock(file);
3495 MSVCRT__unlock_file(file);
3496
3497 return ret;
3498 }
3499
3500 /*********************************************************************
3501 * _fclose_nolock (MSVCRT.@)
3502 */
3503 int CDECL MSVCRT__fclose_nolock(MSVCRT_FILE* file)
3504 {
3505 int r, flag;
3506
3507 flag = file->_flag;
3508 MSVCRT_free(file->_tmpfname);
3509 file->_tmpfname = NULL;
3510 /* flush stdio buffers */
3511 if(file->_flag & MSVCRT__IOWRT)
3512 MSVCRT__fflush_nolock(file);
3513 if(file->_flag & MSVCRT__IOMYBUF)
3514 MSVCRT_free(file->_base);
3515
3516 r=MSVCRT__close(file->_file);
3517 file->_flag = 0;
3518
3519 return ((r == -1) || (flag & MSVCRT__IOERR) ? MSVCRT_EOF : 0);
3520 }
3521
3522 /*********************************************************************
3523 * feof (MSVCRT.@)
3524 */
3525 int CDECL MSVCRT_feof(MSVCRT_FILE* file)
3526 {
3527 return file->_flag & MSVCRT__IOEOF;
3528 }
3529
3530 /*********************************************************************
3531 * ferror (MSVCRT.@)
3532 */
3533 int CDECL MSVCRT_ferror(MSVCRT_FILE* file)
3534 {
3535 return file->_flag & MSVCRT__IOERR;
3536 }
3537
3538 /*********************************************************************
3539 * _filbuf (MSVCRT.@)
3540 */
3541 int CDECL MSVCRT__filbuf(MSVCRT_FILE* file)
3542 {
3543 unsigned char c;
3544
3545 if(file->_flag & MSVCRT__IOSTRG)
3546 return MSVCRT_EOF;
3547
3548 /* Allocate buffer if needed */
3549 if(!(file->_flag & (MSVCRT__IONBF | MSVCRT__IOMYBUF | MSVCRT__USERBUF)))
3550 msvcrt_alloc_buffer(file);
3551
3552 if(!(file->_flag & MSVCRT__IOREAD)) {
3553 if(file->_flag & MSVCRT__IORW)
3554 file->_flag |= MSVCRT__IOREAD;
3555 else
3556 return MSVCRT_EOF;
3557 }
3558
3559 if(!(file->_flag & (MSVCRT__IOMYBUF | MSVCRT__USERBUF))) {
3560 int r;
3561 if ((r = MSVCRT__read(file->_file,&c,1)) != 1) {
3562 file->_flag |= (r == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
3563 return MSVCRT_EOF;
3564 }
3565
3566 return c;
3567 } else {
3568 file->_cnt = MSVCRT__read(file->_file, file->_base, file->_bufsiz);
3569 if(file->_cnt<=0) {
3570 file->_flag |= (file->_cnt == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
3571 file->_cnt = 0;
3572 return MSVCRT_EOF;
3573 }
3574
3575 file->_cnt--;
3576 file->_ptr = file->_base+1;
3577 c = *(unsigned char *)file->_base;
3578 return c;
3579 }
3580 }
3581
3582 /*********************************************************************
3583 * fgetc (MSVCRT.@)
3584 */
3585 int CDECL MSVCRT_fgetc(MSVCRT_FILE* file)
3586 {
3587 int ret;
3588
3589 MSVCRT__lock_file(file);
3590 ret = MSVCRT__fgetc_nolock(file);
3591 MSVCRT__unlock_file(file);
3592
3593 return ret;
3594 }
3595
3596 /*********************************************************************
3597 * _fgetc_nolock (MSVCRT.@)
3598 */
3599 int CDECL MSVCRT__fgetc_nolock(MSVCRT_FILE* file)
3600 {
3601 unsigned char *i;
3602 unsigned int j;
3603
3604 if (file->_cnt>0) {
3605 file->_cnt--;
3606 i = (unsigned char *)file->_ptr++;
3607 j = *i;
3608 } else
3609 j = MSVCRT__filbuf(file);
3610
3611 return j;
3612 }
3613
3614 /*********************************************************************
3615 * _fgetchar (MSVCRT.@)
3616 */
3617 int CDECL MSVCRT__fgetchar(void)
3618 {
3619 return MSVCRT_fgetc(MSVCRT_stdin);
3620 }
3621
3622 /*********************************************************************
3623 * fgets (MSVCRT.@)
3624 */
3625 char * CDECL MSVCRT_fgets(char *s, int size, MSVCRT_FILE* file)
3626 {
3627 int cc = MSVCRT_EOF;
3628 char * buf_start = s;
3629
3630 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
3631 file,file->_file,s,size);
3632
3633 MSVCRT__lock_file(file);
3634
3635 while ((size >1) && (cc = MSVCRT__fgetc_nolock(file)) != MSVCRT_EOF && cc != '\n')
3636 {
3637 *s++ = (char)cc;
3638 size --;
3639 }
3640 if ((cc == MSVCRT_EOF) && (s == buf_start)) /* If nothing read, return 0*/
3641 {
3642 TRACE(":nothing read\n");
3643 MSVCRT__unlock_file(file);
3644 return NULL;
3645 }
3646 if ((cc != MSVCRT_EOF) && (size > 1))
3647 *s++ = cc;
3648 *s = '\0';
3649 TRACE(":got %s\n", debugstr_a(buf_start));
3650 MSVCRT__unlock_file(file);
3651 return buf_start;
3652 }
3653
3654 /*********************************************************************
3655 * fgetwc (MSVCRT.@)
3656 */
3657 MSVCRT_wint_t CDECL MSVCRT_fgetwc(MSVCRT_FILE* file)
3658 {
3659 MSVCRT_wint_t ret;
3660
3661 MSVCRT__lock_file(file);
3662 ret = MSVCRT__fgetwc_nolock(file);
3663 MSVCRT__unlock_file(file);
3664
3665 return ret;
3666 }
3667
3668 /*********************************************************************
3669 * _fgetwc_nolock (MSVCRT.@)
3670 */
3671 MSVCRT_wint_t CDECL MSVCRT__fgetwc_nolock(MSVCRT_FILE* file)
3672 {
3673 MSVCRT_wint_t ret;
3674 int ch;
3675
3676 if((get_ioinfo_nolock(file->_file)->exflag & (EF_UTF8 | EF_UTF16))
3677 || !(get_ioinfo_nolock(file->_file)->wxflag & WX_TEXT)) {
3678 char *p;
3679
3680 for(p=(char*)&ret; (MSVCRT_wint_t*)p<&ret+1; p++) {
3681 ch = MSVCRT__fgetc_nolock(file);
3682 if(ch == MSVCRT_EOF) {
3683 ret = MSVCRT_WEOF;
3684 break;
3685 }
3686 *p = (char)ch;
3687 }
3688 }else {
3689 char mbs[MSVCRT_MB_LEN_MAX];
3690 int len = 0;
3691
3692 ch = MSVCRT__fgetc_nolock(file);
3693 if(ch != MSVCRT_EOF) {
3694 mbs[0] = (char)ch;
3695 if(MSVCRT_isleadbyte((unsigned char)mbs[0])) {
3696 ch = MSVCRT__fgetc_nolock(file);
3697 if(ch != MSVCRT_EOF) {
3698 mbs[1] = (char)ch;
3699 len = 2;
3700 }
3701 }else {
3702 len = 1;
3703 }
3704 }
3705
3706 if(!len || MSVCRT_mbtowc(&ret, mbs, len)==-1)
3707 ret = MSVCRT_WEOF;
3708 }
3709
3710 return ret;
3711 }
3712
3713 /*********************************************************************
3714 * _getw (MSVCRT.@)
3715 */
3716 int CDECL MSVCRT__getw(MSVCRT_FILE* file)
3717 {
3718 char *ch;
3719 int i, k;
3720 unsigned int j;
3721 ch = (char *)&i;
3722
3723 MSVCRT__lock_file(file);
3724 for (j=0; j<sizeof(int); j++) {
3725 k = MSVCRT__fgetc_nolock(file);
3726 if (k == MSVCRT_EOF) {
3727 file->_flag |= MSVCRT__IOEOF;
3728 MSVCRT__unlock_file(file);
3729 return EOF;
3730 }
3731 ch[j] = k;
3732 }
3733
3734 MSVCRT__unlock_file(file);
3735 return i;
3736 }
3737
3738 /*********************************************************************
3739 * getwc (MSVCRT.@)
3740 */
3741 MSVCRT_wint_t CDECL MSVCRT_getwc(MSVCRT_FILE* file)
3742 {
3743 return MSVCRT_fgetwc(file);
3744 }
3745
3746 /*********************************************************************
3747 * _fgetwchar (MSVCRT.@)
3748 */
3749 MSVCRT_wint_t CDECL MSVCRT__fgetwchar(void)
3750 {
3751 return MSVCRT_fgetwc(MSVCRT_stdin);
3752 }
3753
3754 /*********************************************************************
3755 * getwchar (MSVCRT.@)
3756 */
3757 MSVCRT_wint_t CDECL MSVCRT_getwchar(void)
3758 {
3759 return MSVCRT__fgetwchar();
3760 }
3761
3762 /*********************************************************************
3763 * fgetws (MSVCRT.@)
3764 */
3765 MSVCRT_wchar_t * CDECL MSVCRT_fgetws(MSVCRT_wchar_t *s, int size, MSVCRT_FILE* file)
3766 {
3767 MSVCRT_wint_t cc = MSVCRT_WEOF;
3768 MSVCRT_wchar_t * buf_start = s;
3769
3770 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
3771 file,file->_file,s,size);
3772
3773 MSVCRT__lock_file(file);
3774
3775 while ((size >1) && (cc = MSVCRT__fgetwc_nolock(file)) != MSVCRT_WEOF && cc != '\n')
3776 {
3777 *s++ = cc;
3778 size --;
3779 }
3780 if ((cc == MSVCRT_WEOF) && (s == buf_start)) /* If nothing read, return 0*/
3781 {
3782 TRACE(":nothing read\n");
3783 MSVCRT__unlock_file(file);
3784 return NULL;
3785 }
3786 if ((cc != MSVCRT_WEOF) && (size > 1))
3787 *s++ = cc;
3788 *s = 0;
3789 TRACE(":got %s\n", debugstr_w(buf_start));
3790 MSVCRT__unlock_file(file);
3791 return buf_start;
3792 }
3793
3794 /*********************************************************************
3795 * _flsbuf (MSVCRT.@)
3796 */
3797 int CDECL MSVCRT__flsbuf(int c, MSVCRT_FILE* file)
3798 {
3799 /* Flush output buffer */
3800 if(!(file->_flag & (MSVCRT__IONBF | MSVCRT__IOMYBUF | MSVCRT__USERBUF))) {
3801 msvcrt_alloc_buffer(file);
3802 }
3803
3804 if(!(file->_flag & MSVCRT__IOWRT)) {
3805 if(!(file->_flag & MSVCRT__IORW)) {
3806 file->_flag |= MSVCRT__IOERR;
3807 return MSVCRT_EOF;
3808 }
3809 file->_flag |= MSVCRT__IOWRT;
3810 }
3811 if(file->_flag & MSVCRT__IOREAD) {
3812 if(!(file->_flag & MSVCRT__IOEOF)) {
3813 file->_flag |= MSVCRT__IOERR;
3814 return MSVCRT_EOF;
3815 }
3816 file->_cnt = 0;
3817 file->_ptr = file->_base;
3818 file->_flag &= ~(MSVCRT__IOREAD | MSVCRT__IOEOF);
3819 }
3820
3821 if(file->_flag & (MSVCRT__IOMYBUF | MSVCRT__USERBUF)) {
3822 int res = 0;
3823
3824 if(file->_cnt <= 0) {
3825 res = msvcrt_flush_buffer(file);
3826 if(res)
3827 return res;
3828 file->_flag |= MSVCRT__IOWRT;
3829 file->_cnt=file->_bufsiz;
3830 }
3831 *file->_ptr++ = c;
3832 file->_cnt--;
3833 return c&0xff;
3834 } else {
3835 unsigned char cc=c;
3836 int len;
3837 /* set _cnt to 0 for unbuffered FILEs */
3838 file->_cnt = 0;
3839 len = MSVCRT__write(file->_file, &cc, 1);
3840 if (len == 1)
3841 return c & 0xff;
3842 file->_flag |= MSVCRT__IOERR;
3843 return MSVCRT_EOF;
3844 }
3845 }
3846
3847 /*********************************************************************
3848 * fwrite (MSVCRT.@)
3849 */
3850 MSVCRT_size_t CDECL MSVCRT_fwrite(const void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
3851 {
3852 MSVCRT_size_t ret;
3853
3854 MSVCRT__lock_file(file);
3855 ret = MSVCRT__fwrite_nolock(ptr, size, nmemb, file);
3856 MSVCRT__unlock_file(file);
3857
3858 return ret;
3859 }
3860
3861 /*********************************************************************
3862 * _fwrite_nolock (MSVCRT.@)
3863 */
3864 MSVCRT_size_t CDECL MSVCRT__fwrite_nolock(const void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
3865 {
3866 MSVCRT_size_t wrcnt=size * nmemb;
3867 int written = 0;
3868 if (size == 0)
3869 return 0;
3870
3871 while(wrcnt) {
3872 if(file->_cnt < 0) {
3873 WARN("negative file->_cnt value in %p\n", file);
3874 file->_flag |= MSVCRT__IOERR;
3875 break;
3876 } else if(file->_cnt) {
3877 int pcnt=(file->_cnt>wrcnt)? wrcnt: file->_cnt;
3878 memcpy(file->_ptr, ptr, pcnt);
3879 file->_cnt -= pcnt;
3880 file->_ptr += pcnt;
3881 written += pcnt;
3882 wrcnt -= pcnt;
3883 ptr = (const char*)ptr + pcnt;
3884 } else if((file->_flag & MSVCRT__IONBF)
3885 || ((file->_flag & (MSVCRT__IOMYBUF | MSVCRT__USERBUF)) && wrcnt >= file->_bufsiz)
3886 || (!(file->_flag & (MSVCRT__IOMYBUF | MSVCRT__USERBUF)) && wrcnt >= MSVCRT_INTERNAL_BUFSIZ)) {
3887 MSVCRT_size_t pcnt;
3888 int bufsiz;
3889
3890 if(file->_flag & MSVCRT__IONBF)
3891 bufsiz = 1;
3892 else if(!(file->_flag & (MSVCRT__IOMYBUF | MSVCRT__USERBUF)))
3893 bufsiz = MSVCRT_INTERNAL_BUFSIZ;
3894 else
3895 bufsiz = file->_bufsiz;
3896
3897 pcnt = (wrcnt / bufsiz) * bufsiz;
3898
3899 if(msvcrt_flush_buffer(file) == MSVCRT_EOF)
3900 break;
3901
3902 if(MSVCRT__write(file->_file, ptr, pcnt) <= 0) {
3903 file->_flag |= MSVCRT__IOERR;
3904 break;
3905 }
3906 written += pcnt;
3907 wrcnt -= pcnt;
3908 ptr = (const char*)ptr + pcnt;
3909 } else {
3910 if(MSVCRT__flsbuf(*(const char*)ptr, file) == MSVCRT_EOF)
3911 break;
3912 written++;
3913 wrcnt--;
3914 ptr = (const char*)ptr + 1;
3915 }
3916 }
3917
3918 return written / size;
3919 }
3920
3921 /*********************************************************************
3922 * fputwc (MSVCRT.@)
3923 */
3924 MSVCRT_wint_t CDECL MSVCRT_fputwc(MSVCRT_wint_t wc, MSVCRT_FILE* file)
3925 {
3926 MSVCRT_wint_t ret;
3927
3928 MSVCRT__lock_file(file);
3929 ret = MSVCRT__fputwc_nolock(wc, file);
3930 MSVCRT__unlock_file(file);
3931
3932 return ret;
3933 }
3934
3935 /*********************************************************************
3936 * _fputwc_nolock (MSVCRT.@)
3937 */
3938 MSVCRT_wint_t CDECL MSVCRT__fputwc_nolock(MSVCRT_wint_t wc, MSVCRT_FILE* file)
3939 {
3940 MSVCRT_wchar_t mwc=wc;
3941 ioinfo *fdinfo;
3942 MSVCRT_wint_t ret;
3943
3944 fdinfo = get_ioinfo_nolock(file->_file);
3945
3946 if((fdinfo->wxflag&WX_TEXT) && !(fdinfo->exflag&(EF_UTF8|EF_UTF16))) {
3947 char buf[MSVCRT_MB_LEN_MAX];
3948 int char_len;
3949
3950 char_len = MSVCRT_wctomb(buf, mwc);
3951 if(char_len!=-1 && MSVCRT__fwrite_nolock(buf, char_len, 1, file)==1)
3952 ret = wc;
3953 else
3954 ret = MSVCRT_WEOF;
3955 }else if(MSVCRT__fwrite_nolock(&mwc, sizeof(mwc), 1, file) == 1) {
3956 ret = wc;
3957 }else {
3958 ret = MSVCRT_WEOF;
3959 }
3960
3961 return ret;
3962 }
3963
3964 /*********************************************************************
3965 * _fputwchar (MSVCRT.@)
3966 */
3967 MSVCRT_wint_t CDECL MSVCRT__fputwchar(MSVCRT_wint_t wc)
3968 {
3969 return MSVCRT_fputwc(wc, MSVCRT_stdout);
3970 }
3971
3972 /*********************************************************************
3973 * _wfsopen (MSVCRT.@)
3974 */
3975 MSVCRT_FILE * CDECL MSVCRT__wfsopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, int share)
3976 {
3977 MSVCRT_FILE* file;
3978 int open_flags, stream_flags, fd;
3979
3980 TRACE("(%s,%s)\n", debugstr_w(path), debugstr_w(mode));
3981
3982 /* map mode string to open() flags. "man fopen" for possibilities. */
3983 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1)
3984 return NULL;
3985
3986 LOCK_FILES();
3987 fd = MSVCRT__wsopen(path, open_flags, share, MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
3988 if (fd < 0)
3989 file = NULL;
3990 else if ((file = msvcrt_alloc_fp()) && msvcrt_init_fp(file, fd, stream_flags)
3991 != -1)
3992 TRACE(":fd (%d) mode (%s) FILE* (%p)\n", fd, debugstr_w(mode), file);
3993 else if (file)
3994 {
3995 file->_flag = 0;
3996 file = NULL;
3997 }
3998
3999 TRACE(":got (%p)\n",file);
4000 if (fd >= 0 && !file)
4001 MSVCRT__close(fd);
4002 UNLOCK_FILES();
4003 return file;
4004 }
4005
4006 /*********************************************************************
4007 * _fsopen (MSVCRT.@)
4008 */
4009 MSVCRT_FILE * CDECL MSVCRT__fsopen(const char *path, const char *mode, int share)
4010 {
4011 MSVCRT_FILE *ret;
4012 MSVCRT_wchar_t *pathW = NULL, *modeW = NULL;
4013
4014 if (path && !(pathW = msvcrt_wstrdupa(path))) {
4015 MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
4016 *MSVCRT__errno() = MSVCRT_EINVAL;
4017 return NULL;
4018 }
4019 if (mode && !(modeW = msvcrt_wstrdupa(mode)))
4020 {
4021 MSVCRT_free(pathW);
4022 MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
4023 *MSVCRT__errno() = MSVCRT_EINVAL;
4024 return NULL;
4025 }
4026
4027 ret = MSVCRT__wfsopen(pathW, modeW, share);
4028
4029 MSVCRT_free(pathW);
4030 MSVCRT_free(modeW);
4031 return ret;
4032 }
4033
4034 /*********************************************************************
4035 * fopen (MSVCRT.@)
4036 */
4037 MSVCRT_FILE * CDECL MSVCRT_fopen(const char *path, const char *mode)
4038 {
4039 return MSVCRT__fsopen( path, mode, MSVCRT__SH_DENYNO );
4040 }
4041
4042 /*********************************************************************
4043 * fopen_s (MSVCRT.@)
4044 */
4045 int CDECL MSVCRT_fopen_s(MSVCRT_FILE** pFile,
4046 const char *filename, const char *mode)
4047 {
4048 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
4049 if (!MSVCRT_CHECK_PMT(filename != NULL)) return MSVCRT_EINVAL;
4050 if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
4051
4052 *pFile = MSVCRT_fopen(filename, mode);
4053
4054 if(!*pFile)
4055 return *MSVCRT__errno();
4056 return 0;
4057 }
4058
4059 /*********************************************************************
4060 * _wfopen (MSVCRT.@)
4061 */
4062 MSVCRT_FILE * CDECL MSVCRT__wfopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode)
4063 {
4064 return MSVCRT__wfsopen( path, mode, MSVCRT__SH_DENYNO );
4065 }
4066
4067 /*********************************************************************
4068 * _wfopen_s (MSVCRT.@)
4069 */
4070 int CDECL MSVCRT__wfopen_s(MSVCRT_FILE** pFile, const MSVCRT_wchar_t *filename,
4071 const MSVCRT_wchar_t *mode)
4072 {
4073 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
4074 if (!MSVCRT_CHECK_PMT(filename != NULL)) return MSVCRT_EINVAL;
4075 if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
4076
4077 *pFile = MSVCRT__wfopen(filename, mode);
4078
4079 if(!*pFile)
4080 return *MSVCRT__errno();
4081 return 0;
4082 }
4083
4084 /*********************************************************************
4085 * fputc (MSVCRT.@)
4086 */
4087 int CDECL MSVCRT_fputc(int c, MSVCRT_FILE* file)
4088 {
4089 int ret;
4090
4091 MSVCRT__lock_file(file);
4092 ret = MSVCRT__fputc_nolock(c, file);
4093 MSVCRT__unlock_file(file);
4094
4095 return ret;
4096 }
4097
4098 /*********************************************************************
4099 * _fputc_nolock (MSVCRT.@)
4100 */
4101 int CDECL MSVCRT__fputc_nolock(int c, MSVCRT_FILE* file)
4102 {
4103 int res;
4104
4105 if(file->_cnt>0) {
4106 *file->_ptr++=c;
4107 file->_cnt--;
4108 if (c == '\n')
4109 {
4110 res = msvcrt_flush_buffer(file);
4111 return res ? res : c;
4112 }
4113 else {
4114 return c & 0xff;
4115 }
4116 } else {
4117 res = MSVCRT__flsbuf(c, file);
4118 return res;
4119 }
4120 }
4121
4122 /*********************************************************************
4123 * _fputchar (MSVCRT.@)
4124 */
4125 int CDECL MSVCRT__fputchar(int c)
4126 {
4127 return MSVCRT_fputc(c, MSVCRT_stdout);
4128 }
4129
4130 /*********************************************************************
4131 * fread (MSVCRT.@)
4132 */
4133 MSVCRT_size_t CDECL MSVCRT_fread(void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
4134 {
4135 MSVCRT_size_t ret;
4136
4137 MSVCRT__lock_file(file);
4138 ret = MSVCRT__fread_nolock(ptr, size, nmemb, file);
4139 MSVCRT__unlock_file(file);
4140
4141 return ret;
4142 }
4143
4144 /*********************************************************************
4145 * _fread_nolock (MSVCRT.@)
4146 */
4147 MSVCRT_size_t CDECL MSVCRT__fread_nolock(void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
4148 {
4149 MSVCRT_size_t rcnt=size * nmemb;
4150 MSVCRT_size_t read=0;
4151 MSVCRT_size_t pread=0;
4152
4153 if(!rcnt)
4154 return 0;
4155
4156 /* first buffered data */
4157 if(file->_cnt>0) {
4158 int pcnt= (rcnt>file->_cnt)? file->_cnt:rcnt;
4159 memcpy(ptr, file->_ptr, pcnt);
4160 file->_cnt -= pcnt;
4161 file->_ptr += pcnt;
4162 read += pcnt ;
4163 rcnt -= pcnt ;
4164 ptr = (char*)ptr + pcnt;
4165 } else if(!(file->_flag & MSVCRT__IOREAD )) {
4166 if(file->_flag & MSVCRT__IORW) {
4167 file->_flag |= MSVCRT__IOREAD;
4168 } else {
4169 return 0;
4170 }
4171 }
4172
4173 if(rcnt>0 && !(file->_flag & (MSVCRT__IONBF | MSVCRT__IOMYBUF | MSVCRT__USERBUF)))
4174 msvcrt_alloc_buffer(file);
4175
4176 while(rcnt>0)
4177 {
4178 int i;
4179 if (!file->_cnt && rcnt<MSVCRT_BUFSIZ && (file->_flag & (MSVCRT__IOMYBUF | MSVCRT__USERBUF))) {
4180 file->_cnt = MSVCRT__read(file->_file, file->_base, file->_bufsiz);
4181 file->_ptr = file->_base;
4182 i = (file->_cnt<rcnt) ? file->_cnt : rcnt;
4183 /* If the buffer fill reaches eof but fread wouldn't, clear eof. */
4184 if (i > 0 && i < file->_cnt) {
4185 get_ioinfo_nolock(file->_file)->wxflag &= ~WX_ATEOF;
4186 file->_flag &= ~MSVCRT__IOEOF;
4187 }
4188 if (i > 0) {
4189 memcpy(ptr, file->_ptr, i);
4190 file->_cnt -= i;
4191 file->_ptr += i;
4192 }
4193 } else if (rcnt > INT_MAX) {
4194 i = MSVCRT__read(file->_file, ptr, INT_MAX);
4195 } else if (rcnt < MSVCRT_BUFSIZ) {
4196 i = MSVCRT__read(file->_file, ptr, rcnt);
4197 } else {
4198 i = MSVCRT__read(file->_file, ptr, rcnt - MSVCRT_BUFSIZ/2);
4199 }
4200 pread += i;
4201 rcnt -= i;
4202 ptr = (char *)ptr+i;
4203 /* expose feof condition in the flags
4204 * MFC tests file->_flag for feof, and doesn't call feof())
4205 */
4206 if (get_ioinfo_nolock(file->_file)->wxflag & WX_ATEOF)
4207 file->_flag |= MSVCRT__IOEOF;
4208 else if (i == -1)
4209 {
4210 file->_flag |= MSVCRT__IOERR;
4211 pread = 0;
4212 rcnt = 0;
4213 }
4214 if (i < 1) break;
4215 }
4216 read+=pread;
4217 return read / size;
4218 }
4219
4220
4221 /*********************************************************************
4222 * fread_s (MSVCR80.@)
4223 */
4224 MSVCRT_size_t CDECL MSVCRT_fread_s(void *buf, MSVCRT_size_t buf_size, MSVCRT_size_t elem_size,
4225 MSVCRT_size_t count, MSVCRT_FILE *stream)
4226 {
4227 MSVCRT_size_t ret;
4228
4229 if(!MSVCRT_CHECK_PMT(stream != NULL)) {
4230 if(buf && buf_size)
4231 memset(buf, 0, buf_size);
4232 return 0;
4233 }
4234 if(!elem_size || !count) return 0;
4235
4236 MSVCRT__lock_file(stream);
4237 ret = MSVCRT__fread_nolock_s(buf, buf_size, elem_size, count, stream);
4238 MSVCRT__unlock_file(stream);
4239
4240 return ret;
4241 }
4242
4243 /*********************************************************************
4244 * _fread_nolock_s (MSVCR80.@)
4245 */
4246 MSVCRT_size_t CDECL MSVCRT__fread_nolock_s(void *buf, MSVCRT_size_t buf_size, MSVCRT_size_t elem_size,
4247 MSVCRT_size_t count, MSVCRT_FILE *stream)
4248 {
4249 size_t bytes_left, buf_pos;
4250
4251 TRACE("(%p %lu %lu %lu %p)\n", buf, buf_size, elem_size, count, stream);
4252
4253 if(!MSVCRT_CHECK_PMT(stream != NULL)) {
4254 if(buf && buf_size)
4255 memset(buf, 0, buf_size);
4256 return 0;
4257 }
4258 if(!elem_size || !count) return 0;
4259 if(!MSVCRT_CHECK_PMT(buf != NULL)) return 0;
4260 if(!MSVCRT_CHECK_PMT(MSVCRT_SIZE_MAX/count >= elem_size)) return 0;
4261
4262 bytes_left = elem_size*count;
4263 buf_pos = 0;
4264 while(bytes_left) {
4265 if(stream->_cnt > 0) {
4266 size_t size = bytes_left<stream->_cnt ? bytes_left : stream->_cnt;
4267
4268 if(!MSVCRT_CHECK_PMT_ERR(size <= buf_size-buf_pos, MSVCRT_ERANGE)) {
4269 memset(buf, 0, buf_size);
4270 return 0;
4271 }
4272
4273 MSVCRT__fread_nolock((char*)buf+buf_pos, 1, size, stream);
4274 buf_pos += size;
4275 bytes_left -= size;
4276 }else {
4277 int c = MSVCRT__filbuf(stream);
4278
4279 if(c == EOF)
4280 break;
4281
4282 if(!MSVCRT_CHECK_PMT_ERR(buf_size != buf_pos, MSVCRT_ERANGE)) {
4283 memset(buf, 0, buf_size);
4284 return 0;
4285 }
4286
4287 ((char*)buf)[buf_pos++] = c;
4288 bytes_left--;
4289 }
4290 }
4291
4292 return buf_pos/elem_size;
4293 }
4294
4295 /*********************************************************************
4296 * _wfreopen (MSVCRT.@)
4297 *
4298 */
4299 MSVCRT_FILE* CDECL MSVCRT__wfreopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, MSVCRT_FILE* file)
4300 {
4301 int open_flags, stream_flags, fd;
4302
4303 TRACE(":path (%s) mode (%s) file (%p) fd (%d)\n", debugstr_w(path), debugstr_w(mode), file, file ? file->_file : -1);
4304
4305 LOCK_FILES();
4306 if (!file || ((fd = file->_file) < 0) || fd > MSVCRT_fdend)
4307 file = NULL;
4308 else
4309 {
4310 MSVCRT_fclose(file);
4311 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1)
4312 file = NULL;
4313 else if((fd = MSVCRT__wopen(path, open_flags, MSVCRT__S_IREAD | MSVCRT__S_IWRITE)) < 0)
4314 file = NULL;
4315 else if(msvcrt_init_fp(file, fd, stream_flags) == -1)
4316 {
4317 file->_flag = 0;
4318 file = NULL;
4319 }
4320 }
4321 UNLOCK_FILES();
4322 return file;
4323 }
4324
4325 /*********************************************************************
4326 * _wfreopen_s (MSVCRT.@)
4327 */
4328 int CDECL MSVCRT__wfreopen_s(MSVCRT_FILE** pFile,
4329 const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, MSVCRT_FILE* file)
4330 {
4331 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
4332 if (!MSVCRT_CHECK_PMT(path != NULL)) return MSVCRT_EINVAL;
4333 if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
4334 if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
4335
4336 *pFile = MSVCRT__wfreopen(path, mode, file);
4337
4338 if(!*pFile)
4339 return *MSVCRT__errno();
4340 return 0;
4341 }
4342
4343 /*********************************************************************
4344 * freopen (MSVCRT.@)
4345 *
4346 */
4347 MSVCRT_FILE* CDECL MSVCRT_freopen(const char *path, const char *mode, MSVCRT_FILE* file)
4348 {
4349 MSVCRT_FILE *ret;
4350 MSVCRT_wchar_t *pathW = NULL, *modeW = NULL;
4351
4352 if (path && !(pathW = msvcrt_wstrdupa(path))) return NULL;
4353 if (mode && !(modeW = msvcrt_wstrdupa(mode)))
4354 {
4355 MSVCRT_free(pathW);
4356 return NULL;
4357 }
4358
4359 ret = MSVCRT__wfreopen(pathW, modeW, file);
4360
4361 MSVCRT_free(pathW);
4362 MSVCRT_free(modeW);
4363 return ret;
4364 }
4365
4366 /*********************************************************************
4367 * freopen_s (MSVCRT.@)
4368 */
4369 int CDECL MSVCRT_freopen_s(MSVCRT_FILE** pFile,
4370 const char *path, const char *mode, MSVCRT_FILE* file)
4371 {
4372 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
4373 if (!MSVCRT_CHECK_PMT(path != NULL)) return MSVCRT_EINVAL;
4374 if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
4375 if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
4376
4377 *pFile = MSVCRT_freopen(path, mode, file);
4378
4379 if(!*pFile)
4380 return *MSVCRT__errno();
4381 return 0;
4382 }
4383
4384 /*********************************************************************
4385 * fsetpos (MSVCRT.@)
4386 */
4387 int CDECL MSVCRT_fsetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
4388 {
4389 int ret;
4390
4391 MSVCRT__lock_file(file);
4392 msvcrt_flush_buffer(file);
4393
4394 /* Reset direction of i/o */
4395 if(file->_flag & MSVCRT__IORW) {
4396 file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
4397 }
4398
4399 ret = (MSVCRT__lseeki64(file->_file,*pos,SEEK_SET) == -1) ? -1 : 0;
4400 MSVCRT__unlock_file(file);
4401 return ret;
4402 }
4403
4404 /*********************************************************************
4405 * _ftelli64 (MSVCRT.@)
4406 */
4407 __int64 CDECL MSVCRT__ftelli64(MSVCRT_FILE* file)
4408 {
4409 __int64 ret;
4410
4411 MSVCRT__lock_file(file);
4412 ret = MSVCRT__ftelli64_nolock(file);
4413 MSVCRT__unlock_file(file);
4414
4415 return ret;
4416 }
4417
4418 /*********************************************************************
4419 * _ftelli64_nolock (MSVCRT.@)
4420 */
4421 __int64 CDECL MSVCRT__ftelli64_nolock(MSVCRT_FILE* file)
4422 {
4423 __int64 pos;
4424
4425 pos = _telli64(file->_file);
4426 if(pos == -1)
4427 return -1;
4428 if(file->_flag & (MSVCRT__IOMYBUF | MSVCRT__USERBUF)) {
4429 if(file->_flag & MSVCRT__IOWRT) {
4430 pos += file->_ptr - file->_base;
4431
4432 if(get_ioinfo_nolock(file->_file)->wxflag & WX_TEXT) {
4433 char *p;
4434
4435 for(p=file->_base; p<file->_ptr; p++)
4436 if(*p == '\n')
4437 pos++;
4438 }
4439 } else if(!file->_cnt) { /* nothing to do */
4440 } else if(MSVCRT__lseeki64(file->_file, 0, SEEK_END)==pos) {
4441 int i;
4442
4443 pos -= file->_cnt;
4444 if(get_ioinfo_nolock(file->_file)->wxflag & WX_TEXT) {
4445 for(i=0; i<file->_cnt; i++)
4446 if(file->_ptr[i] == '\n')
4447 pos--;
4448 }
4449 } else {
4450 char *p;
4451
4452 if(MSVCRT__lseeki64(file->_file, pos, SEEK_SET) != pos)
4453 return -1;
4454
4455 pos -= file->_bufsiz;
4456 pos += file->_ptr - file->_base;
4457
4458 if(get_ioinfo_nolock(file->_file)->wxflag & WX_TEXT) {
4459 if(get_ioinfo_nolock(file->_file)->wxflag & WX_READNL)
4460 pos--;
4461
4462 for(p=file->_base; p<file->_ptr; p++)
4463 if(*p == '\n')
4464 pos++;
4465 }
4466 }
4467 }
4468
4469 return pos;
4470 }
4471
4472 /*********************************************************************
4473 * ftell (MSVCRT.@)
4474 */
4475 LONG CDECL MSVCRT_ftell(MSVCRT_FILE* file)
4476 {
4477 return MSVCRT__ftelli64(file);
4478 }
4479
4480 /*********************************************************************
4481 * _ftell_nolock (MSVCRT.@)
4482 */
4483 LONG CDECL MSVCRT__ftell_nolock(MSVCRT_FILE* file)
4484 {
4485 return MSVCRT__ftelli64_nolock(file);
4486 }
4487
4488 /*********************************************************************
4489 * fgetpos (MSVCRT.@)
4490 */
4491 int CDECL MSVCRT_fgetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
4492 {
4493 *pos = MSVCRT__ftelli64(file);
4494 if(*pos == -1)
4495 return -1;
4496 return 0;
4497 }
4498
4499 /*********************************************************************
4500 * fputs (MSVCRT.@)
4501 */
4502 int CDECL MSVCRT_fputs(const char *s, MSVCRT_FILE* file)
4503 {
4504 MSVCRT_size_t len = strlen(s);
4505 int ret;
4506
4507 MSVCRT__lock_file(file);
4508 ret = MSVCRT__fwrite_nolock(s, sizeof(*s), len, file) == len ? 0 : MSVCRT_EOF;
4509 MSVCRT__unlock_file(file);
4510 return ret;
4511 }
4512
4513 /*********************************************************************
4514 * fputws (MSVCRT.@)
4515 */
4516 int CDECL MSVCRT_fputws(const MSVCRT_wchar_t *s, MSVCRT_FILE* file)
4517 {
4518 MSVCRT_size_t i, len = strlenW(s);
4519 BOOL tmp_buf;
4520 int ret;
4521
4522 MSVCRT__lock_file(file);
4523 if (!(get_ioinfo_nolock(file->_file)->wxflag & WX_TEXT)) {
4524 ret = MSVCRT__fwrite_nolock(s,sizeof(*s),len,file) == len ? 0 : MSVCRT_EOF;
4525 MSVCRT__unlock_file(file);
4526 return ret;
4527 }
4528
4529 tmp_buf = add_std_buffer(file);
4530 for (i=0; i<len; i++) {
4531 if(MSVCRT__fputwc_nolock(s[i], file) == MSVCRT_WEOF) {
4532 if(tmp_buf) remove_std_buffer(file);
4533 MSVCRT__unlock_file(file);
4534 return MSVCRT_WEOF;
4535 }
4536 }
4537
4538 if(tmp_buf) remove_std_buffer(file);
4539 MSVCRT__unlock_file(file);
4540 return 0;
4541 }
4542
4543 /*********************************************************************
4544 * getchar (MSVCRT.@)
4545 */
4546 int CDECL MSVCRT_getchar(void)
4547 {
4548 return MSVCRT_fgetc(MSVCRT_stdin);
4549 }
4550
4551 /*********************************************************************
4552 * getc (MSVCRT.@)
4553 */
4554 int CDECL MSVCRT_getc(MSVCRT_FILE* file)
4555 {
4556 return MSVCRT_fgetc(file);
4557 }
4558
4559 /*********************************************************************
4560 * gets (MSVCRT.@)
4561 */
4562 char * CDECL MSVCRT_gets(char *buf)
4563 {
4564 int cc;
4565 char * buf_start = buf;
4566
4567 MSVCRT__lock_file(MSVCRT_stdin);
4568 for(cc = MSVCRT__fgetc_nolock(MSVCRT_stdin); cc != MSVCRT_EOF && cc != '\n';
4569 cc = MSVCRT__fgetc_nolock(MSVCRT_stdin))
4570 if(cc != '\r') *buf++ = (char)cc;
4571
4572 *buf = '\0';
4573
4574 TRACE("got '%s'\n", buf_start);
4575 MSVCRT__unlock_file(MSVCRT_stdin);
4576 return buf_start;
4577 }
4578
4579 /*********************************************************************
4580 * _getws (MSVCRT.@)
4581 */
4582 MSVCRT_wchar_t* CDECL MSVCRT__getws(MSVCRT_wchar_t* buf)
4583 {
4584 MSVCRT_wint_t cc;
4585 MSVCRT_wchar_t* ws = buf;
4586
4587 MSVCRT__lock_file(MSVCRT_stdin);
4588 for (cc = MSVCRT__fgetwc_nolock(MSVCRT_stdin); cc != MSVCRT_WEOF && cc != '\n';
4589 cc = MSVCRT__fgetwc_nolock(MSVCRT_stdin))
4590 {
4591 if (cc != '\r')
4592 *buf++ = (MSVCRT_wchar_t)cc;
4593 }
4594 *buf = '\0';
4595
4596 TRACE("got %s\n", debugstr_w(ws));
4597 MSVCRT__unlock_file(MSVCRT_stdin);
4598 return ws;
4599 }
4600
4601 /*********************************************************************
4602 * putc (MSVCRT.@)
4603 */
4604 int CDECL MSVCRT_putc(int c, MSVCRT_FILE* file)
4605 {
4606 return MSVCRT_fputc(c, file);
4607 }
4608
4609 /*********************************************************************
4610 * putchar (MSVCRT.@)
4611 */
4612 int CDECL MSVCRT_putchar(int c)
4613 {
4614 return MSVCRT_fputc(c, MSVCRT_stdout);
4615 }
4616
4617 /*********************************************************************
4618 * _putwch (MSVCRT.@)
4619 */
4620 int CDECL MSVCRT__putwch(int c)
4621 {
4622 return MSVCRT_fputwc(c, MSVCRT_stdout);
4623 }
4624
4625 /*********************************************************************
4626 * puts (MSVCRT.@)
4627 */
4628 int CDECL MSVCRT_puts(const char *s)
4629 {
4630 MSVCRT_size_t len = strlen(s);
4631 int ret;
4632
4633 MSVCRT__lock_file(MSVCRT_stdout);
4634 if(MSVCRT__fwrite_nolock(s, sizeof(*s), len, MSVCRT_stdout) != len) {
4635 MSVCRT__unlock_file(MSVCRT_stdout);
4636 return MSVCRT_EOF;
4637 }
4638
4639 ret = MSVCRT__fwrite_nolock("\n",1,1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
4640 MSVCRT__unlock_file(MSVCRT_stdout);
4641 return ret;
4642 }
4643
4644 /*********************************************************************
4645 * _putws (MSVCRT.@)
4646 */
4647 int CDECL MSVCRT__putws(const MSVCRT_wchar_t *s)
4648 {
4649 static const MSVCRT_wchar_t nl = '\n';
4650 MSVCRT_size_t len = strlenW(s);
4651 int ret;
4652
4653 MSVCRT__lock_file(MSVCRT_stdout);
4654 if(MSVCRT__fwrite_nolock(s, sizeof(*s), len, MSVCRT_stdout) != len) {
4655 MSVCRT__unlock_file(MSVCRT_stdout);
4656 return MSVCRT_EOF;
4657 }
4658
4659 ret = MSVCRT__fwrite_nolock(&nl,sizeof(nl),1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
4660 MSVCRT__unlock_file(MSVCRT_stdout);
4661 return ret;
4662 }
4663
4664 /*********************************************************************
4665 * remove (MSVCRT.@)
4666 */
4667 int CDECL MSVCRT_remove(const char *path)
4668 {
4669 TRACE("(%s)\n",path);
4670 if (DeleteFileA(path))
4671 return 0;
4672 TRACE(":failed (%d)\n",GetLastError());
4673 msvcrt_set_errno(GetLastError());
4674 return -1;
4675 }
4676
4677 /*********************************************************************
4678 * _wremove (MSVCRT.@)
4679 */
4680 int CDECL MSVCRT__wremove(const MSVCRT_wchar_t *path)
4681 {
4682 TRACE("(%s)\n",debugstr_w(path));
4683 if (DeleteFileW(path))
4684 return 0;
4685 TRACE(":failed (%d)\n",GetLastError());
4686 msvcrt_set_errno(GetLastError());
4687 return -1;
4688 }
4689
4690 /*********************************************************************
4691 * rename (MSVCRT.@)
4692 */
4693 int CDECL MSVCRT_rename(const char *oldpath,const char *newpath)
4694 {
4695 TRACE(":from %s to %s\n",oldpath,newpath);
4696 if (MoveFileExA(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
4697 return 0;
4698 TRACE(":failed (%d)\n",GetLastError());
4699 msvcrt_set_errno(GetLastError());
4700 return -1;
4701 }
4702
4703 /*********************************************************************
4704 * _wrename (MSVCRT.@)
4705 */
4706 int CDECL MSVCRT__wrename(const MSVCRT_wchar_t *oldpath,const MSVCRT_wchar_t *newpath)
4707 {
4708 TRACE(":from %s to %s\n",debugstr_w(oldpath),debugstr_w(newpath));
4709 if (MoveFileExW(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
4710 return 0;
4711 TRACE(":failed (%d)\n",GetLastError());
4712 msvcrt_set_errno(GetLastError());
4713 return -1;
4714 }
4715
4716 /*********************************************************************
4717 * setvbuf (MSVCRT.@)
4718 */
4719 int CDECL MSVCRT_setvbuf(MSVCRT_FILE* file, char *buf, int mode, MSVCRT_size_t size)
4720 {
4721 if(!MSVCRT_CHECK_PMT(file != NULL)) return -1;
4722 if(!MSVCRT_CHECK_PMT(mode==MSVCRT__IONBF || mode==MSVCRT__IOFBF || mode==MSVCRT__IOLBF)) return -1;
4723 if(!MSVCRT_CHECK_PMT(mode==MSVCRT__IONBF || (size>=2 && size<=INT_MAX))) return -1;
4724
4725 MSVCRT__lock_file(file);
4726
4727 MSVCRT__fflush_nolock(file);
4728 if(file->_flag & MSVCRT__IOMYBUF)
4729 MSVCRT_free(file->_base);
4730 file->_flag &= ~(MSVCRT__IONBF | MSVCRT__IOMYBUF | MSVCRT__USERBUF);
4731 file->_cnt = 0;
4732
4733 if(mode == MSVCRT__IONBF) {
4734 file->_flag |= MSVCRT__IONBF;
4735 file->_base = file->_ptr = (char*)&file->_charbuf;
4736 file->_bufsiz = 2;
4737 }else if(buf) {
4738 file->_base = file->_ptr = buf;
4739 file->_flag |= MSVCRT__USERBUF;
4740 file->_bufsiz = size;
4741 }else {
4742 file->_base = file->_ptr = MSVCRT_malloc(size);
4743 if(!file->_base) {
4744 file->_bufsiz = 0;
4745 MSVCRT__unlock_file(file);
4746 return -1;
4747 }
4748
4749 file->_flag |= MSVCRT__IOMYBUF;
4750 file->_bufsiz = size;
4751 }
4752 MSVCRT__unlock_file(file);
4753 return 0;
4754 }
4755
4756 /*********************************************************************
4757 * setbuf (MSVCRT.@)
4758 */
4759 void CDECL MSVCRT_setbuf(MSVCRT_FILE* file, char *buf)
4760 {
4761 MSVCRT_setvbuf(file, buf, buf ? MSVCRT__IOFBF : MSVCRT__IONBF, MSVCRT_BUFSIZ);
4762 }
4763
4764 /*********************************************************************
4765 * tmpnam (MSVCRT.@)
4766 */
4767 char * CDECL MSVCRT_tmpnam(char *s)
4768 {
4769 char tmpstr[16];
4770 char *p;
4771 int count, size;
4772
4773 if (!s) {
4774 thread_data_t *data = msvcrt_get_thread_data();
4775
4776 if(!data->tmpnam_buffer)
4777 data->tmpnam_buffer = MSVCRT_malloc(MAX_PATH);
4778
4779 s = data->tmpnam_buffer;
4780 }
4781
4782 msvcrt_int_to_base32(GetCurrentProcessId(), tmpstr);
4783 p = s + sprintf(s, "\\s%s.", tmpstr);
4784 for (count = 0; count < MSVCRT_TMP_MAX; count++)
4785 {
4786 size = msvcrt_int_to_base32(tmpnam_unique++, tmpstr);
4787 memcpy(p, tmpstr, size);
4788 p[size] = '\0';
4789 if (GetFileAttributesA(s) == INVALID_FILE_ATTRIBUTES &&
4790 GetLastError() == ERROR_FILE_NOT_FOUND)
4791 break;
4792 }
4793 return s;
4794 }
4795
4796 /*********************************************************************
4797 * _wtmpnam (MSVCRT.@)
4798 */
4799 MSVCRT_wchar_t * CDECL MSVCRT_wtmpnam(MSVCRT_wchar_t *s)
4800 {
4801 static const MSVCRT_wchar_t format[] = {'\\','s','%','s','.',0};
4802 MSVCRT_wchar_t tmpstr[16];
4803 MSVCRT_wchar_t *p;
4804 int count, size;
4805 if (!s) {
4806 thread_data_t *data = msvcrt_get_thread_data();
4807
4808 if(!data->wtmpnam_buffer)
4809 data->wtmpnam_buffer = MSVCRT_malloc(sizeof(MSVCRT_wchar_t[MAX_PATH]));
4810
4811 s = data->wtmpnam_buffer;
4812 }
4813
4814 msvcrt_int_to_base32_w(GetCurrentProcessId(), tmpstr);
4815 p = s + MSVCRT__snwprintf(s, MAX_PATH, format, tmpstr);
4816 for (count = 0; count < MSVCRT_TMP_MAX; count++)
4817 {
4818 size = msvcrt_int_to_base32_w(tmpnam_unique++, tmpstr);
4819 memcpy(p, tmpstr, size*sizeof(MSVCRT_wchar_t));
4820 p[size] = '\0';
4821 if (GetFileAttributesW(s) == INVALID_FILE_ATTRIBUTES &&
4822 GetLastError() == ERROR_FILE_NOT_FOUND)
4823 break;
4824 }
4825 return s;
4826 }
4827
4828 /*********************************************************************
4829 * tmpfile (MSVCRT.@)
4830 */
4831 MSVCRT_FILE* CDECL MSVCRT_tmpfile(void)
4832 {
4833 char *filename = MSVCRT_tmpnam(NULL);
4834 int fd;
4835 MSVCRT_FILE* file = NULL;
4836
4837 LOCK_FILES();
4838 fd = MSVCRT__open(filename, MSVCRT__O_CREAT | MSVCRT__O_BINARY | MSVCRT__O_RDWR | MSVCRT__O_TEMPORARY,
4839 MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
4840 if (fd != -1 && (file = msvcrt_alloc_fp()))
4841 {
4842 if (msvcrt_init_fp(file, fd, MSVCRT__IORW) == -1)
4843 {
4844 file->_flag = 0;
4845 file = NULL;
4846 }
4847 else file->_tmpfname = MSVCRT__strdup(filename);
4848 }
4849
4850 if(fd != -1 && !file)
4851 MSVCRT__close(fd);
4852 UNLOCK_FILES();
4853 return file;
4854 }
4855
4856 /*********************************************************************
4857 * tmpfile_s (MSVCRT.@)
4858 */
4859 int CDECL MSVCRT_tmpfile_s(MSVCRT_FILE** file)
4860 {
4861 if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
4862
4863 *file = MSVCRT_tmpfile();
4864 return 0;
4865 }
4866
4867 static int puts_clbk_file_a(void *file, int len, const char *str)
4868 {
4869 return MSVCRT_fwrite(str, sizeof(char), len, file);
4870 }
4871
4872 static int puts_clbk_file_w(void *file, int len, const MSVCRT_wchar_t *str)
4873 {
4874 int i, ret;
4875
4876 MSVCRT__lock_file(file);
4877
4878 if(!(get_ioinfo_nolock(((MSVCRT_FILE*)file)->_file)->wxflag & WX_TEXT)) {
4879 ret = MSVCRT__fwrite_nolock(str, sizeof(MSVCRT_wchar_t), len, file);
4880 MSVCRT__unlock_file(file);
4881 return ret;
4882 }
4883
4884 for(i=0; i<len; i++) {
4885 if(MSVCRT__fputwc_nolock(str[i], file) == MSVCRT_WEOF) {
4886 MSVCRT__unlock_file(file);
4887 return -1;
4888 }
4889 }
4890
4891 MSVCRT__unlock_file(file);
4892 return len;
4893 }
4894
4895 /*********************************************************************
4896 * vfprintf (MSVCRT.@)
4897 */
4898 int CDECL MSVCRT_vfprintf(MSVCRT_FILE* file, const char *format, __ms_va_list valist)
4899 {
4900 BOOL tmp_buf;
4901 int ret;
4902
4903 MSVCRT__lock_file(file);
4904 tmp_buf = add_std_buffer(file);
4905 ret = pf_printf_a(puts_clbk_file_a, file, format, NULL, FALSE, FALSE, arg_clbk_valist, NULL, &valist);
4906 if(tmp_buf) remove_std_buffer(file);
4907 MSVCRT__unlock_file(file);
4908
4909 return ret;
4910 }
4911
4912 /*********************************************************************
4913 * vfprintf_s (MSVCRT.@)
4914 */
4915 int CDECL MSVCRT_vfprintf_s(MSVCRT_FILE* file, const char *format, __ms_va_list valist)
4916 {
4917 BOOL tmp_buf;
4918 int ret;
4919
4920 if(!MSVCRT_CHECK_PMT(file != NULL)) return -1;
4921
4922 MSVCRT__lock_file(file);
4923 tmp_buf = add_std_buffer(file);
4924 ret = pf_printf_a(puts_clbk_file_a, file, format, NULL, FALSE, TRUE, arg_clbk_valist, NULL, &valist);
4925 if(tmp_buf) remove_std_buffer(file);
4926 MSVCRT__unlock_file(file);
4927
4928 return ret;
4929 }
4930
4931 /*********************************************************************
4932 * vfwprintf (MSVCRT.@)
4933 */
4934 int CDECL MSVCRT_vfwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, __ms_va_list valist)
4935 {
4936 BOOL tmp_buf;
4937 int ret;
4938
4939 MSVCRT__lock_file(file);
4940 tmp_buf = add_std_buffer(file);
4941 ret = pf_printf_w(puts_clbk_file_w, file, format, NULL, FALSE, FALSE, arg_clbk_valist, NULL, &valist);
4942 if(tmp_buf) remove_std_buffer(file);
4943 MSVCRT__unlock_file(file);
4944
4945 return ret;
4946 }
4947
4948 /*********************************************************************
4949 * vfwprintf_s (MSVCRT.@)
4950 */
4951 int CDECL MSVCRT_vfwprintf_s(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, __ms_va_list valist)
4952 {
4953 BOOL tmp_buf;
4954 int ret;
4955
4956 if (!MSVCRT_CHECK_PMT( file != NULL )) return -1;
4957
4958 MSVCRT__lock_file(file);
4959 tmp_buf = add_std_buffer(file);
4960 ret = pf_printf_w(puts_clbk_file_w, file, format, NULL, FALSE, TRUE, arg_clbk_valist, NULL, &valist);
4961 if(tmp_buf) remove_std_buffer(file);
4962 MSVCRT__unlock_file(file);
4963
4964 return ret;
4965 }
4966
4967 /*********************************************************************
4968 * _vfwprintf_l (MSVCRT.@)
4969 */
4970 int CDECL MSVCRT__vfwprintf_l(MSVCRT_FILE* file, const MSVCRT_wchar_t *format,
4971 MSVCRT__locale_t locale, __ms_va_list valist)
4972 {
4973 BOOL tmp_buf;
4974 int ret;
4975
4976 if (!MSVCRT_CHECK_PMT( file != NULL )) return -1;
4977
4978 MSVCRT__lock_file(file);
4979 tmp_buf = add_std_buffer(file);
4980 ret = pf_printf_w(puts_clbk_file_w, file, format, locale, FALSE, FALSE, arg_clbk_valist, NULL, &valist);
4981 if(tmp_buf) remove_std_buffer(file);
4982 MSVCRT__unlock_file(file);
4983
4984 return ret;
4985 }
4986
4987 /*********************************************************************
4988 * vprintf (MSVCRT.@)
4989 */
4990 int CDECL MSVCRT_vprintf(const char *format, __ms_va_list valist)
4991 {
4992 return MSVCRT_vfprintf(MSVCRT_stdout,format,valist);
4993 }
4994
4995 /*********************************************************************
4996 * vprintf_s (MSVCRT.@)
4997 */
4998 int CDECL MSVCRT_vprintf_s(const char *format, __ms_va_list valist)
4999 {
5000 return MSVCRT_vfprintf_s(MSVCRT_stdout,format,valist);
5001 }
5002
5003 /*********************************************************************
5004 * vwprintf (MSVCRT.@)
5005 */
5006 int CDECL MSVCRT_vwprintf(const MSVCRT_wchar_t *format, __ms_va_list valist)
5007 {
5008 return MSVCRT_vfwprintf(MSVCRT_stdout,format,valist);
5009 }
5010
5011 /*********************************************************************
5012 * vwprintf_s (MSVCRT.@)
5013 */
5014 int CDECL MSVCRT_vwprintf_s(const MSVCRT_wchar_t *format, __ms_va_list valist)
5015 {
5016 return MSVCRT_vfwprintf_s(MSVCRT_stdout,format,valist);
5017 }
5018
5019 /*********************************************************************
5020 * fprintf (MSVCRT.@)
5021 */
5022 int CDECL MSVCRT_fprintf(MSVCRT_FILE* file, const char *format, ...)
5023 {
5024 __ms_va_list valist;
5025 int res;
5026 __ms_va_start(valist, format);
5027 res = MSVCRT_vfprintf(file, format, valist);
5028 __ms_va_end(valist);
5029 return res;
5030 }
5031
5032 /*********************************************************************
5033 * fprintf_s (MSVCRT.@)
5034 */
5035 int CDECL MSVCRT_fprintf_s(MSVCRT_FILE* file, const char *format, ...)
5036 {
5037 __ms_va_list valist;
5038 int res;
5039 __ms_va_start(valist, format);
5040 res = MSVCRT_vfprintf_s(file, format, valist);
5041 __ms_va_end(valist);
5042 return res;
5043 }
5044
5045 /*********************************************************************
5046 * fwprintf (MSVCRT.@)
5047 */
5048 int CDECL MSVCRT_fwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, ...)
5049 {
5050 __ms_va_list valist;
5051 int res;
5052 __ms_va_start(valist, format);
5053 res = MSVCRT_vfwprintf(file, format, valist);
5054 __ms_va_end(valist);
5055 return res;
5056 }
5057
5058 /*********************************************************************
5059 * fwprintf_s (MSVCRT.@)
5060 */
5061 int CDECL MSVCRT_fwprintf_s(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, ...)
5062 {
5063 __ms_va_list valist;
5064 int res;
5065 __ms_va_start(valist, format);
5066 res = MSVCRT_vfwprintf_s(file, format, valist);
5067 __ms_va_end(valist);
5068 return res;
5069 }
5070
5071 /*********************************************************************
5072 * _fwprintf_l (MSVCRT.@)
5073 */
5074 int CDECL MSVCRT__fwprintf_l(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, ...)
5075 {
5076 __ms_va_list valist;
5077 int res;
5078 __ms_va_start(valist, locale);
5079 res = MSVCRT__vfwprintf_l(file, format, locale, valist);
5080 __ms_va_end(valist);
5081 return res;
5082 }
5083
5084 /*********************************************************************
5085 * printf (MSVCRT.@)
5086 */
5087 int CDECL MSVCRT_printf(const char *format, ...)
5088 {
5089 __ms_va_list valist;
5090 int res;
5091 __ms_va_start(valist, format);
5092 res = MSVCRT_vfprintf(MSVCRT_stdout, format, valist);
5093 __ms_va_end(valist);
5094 return res;
5095 }
5096
5097 /*********************************************************************
5098 * printf_s (MSVCRT.@)
5099 */
5100 int CDECL MSVCRT_printf_s(const char *format, ...)
5101 {
5102 __ms_va_list valist;
5103 int res;
5104 __ms_va_start(valist, format);
5105 res = MSVCRT_vprintf_s(format, valist);
5106 __ms_va_end(valist);
5107 return res;
5108 }
5109
5110 /*********************************************************************
5111 * ungetc (MSVCRT.@)
5112 */
5113 int CDECL MSVCRT_ungetc(int c, MSVCRT_FILE * file)
5114 {
5115 int ret;
5116
5117 if(!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EOF;
5118
5119 MSVCRT__lock_file(file);
5120 ret = MSVCRT__ungetc_nolock(c, file);
5121 MSVCRT__unlock_file(file);
5122
5123 return ret;
5124 }
5125
5126 /*********************************************************************
5127 * _ungetc_nolock (MSVCRT.@)
5128 */
5129 int CDECL MSVCRT__ungetc_nolock(int c, MSVCRT_FILE * file)
5130 {
5131 if(!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EOF;
5132
5133 if (c == MSVCRT_EOF || !(file->_flag&MSVCRT__IOREAD ||
5134 (file->_flag&MSVCRT__IORW && !(file->_flag&MSVCRT__IOWRT))))
5135 return MSVCRT_EOF;
5136
5137 if((!(file->_flag & (MSVCRT__IONBF | MSVCRT__IOMYBUF | MSVCRT__USERBUF))
5138 && msvcrt_alloc_buffer(file))
5139 || (!file->_cnt && file->_ptr==file->_base))
5140 file->_ptr++;
5141
5142 if(file->_ptr>file->_base) {
5143 file->_ptr--;
5144 if(file->_flag & MSVCRT__IOSTRG) {
5145 if(*file->_ptr != c) {
5146 file->_ptr++;
5147 return MSVCRT_EOF;
5148 }
5149 }else {
5150 *file->_ptr = c;
5151 }
5152 file->_cnt++;
5153 file->_flag &= ~(MSVCRT__IOERR | MSVCRT__IOEOF);
5154 file->_flag |= MSVCRT__IOREAD;
5155 return c;
5156 }
5157
5158 return MSVCRT_EOF;
5159 }
5160
5161 /*********************************************************************
5162 * ungetwc (MSVCRT.@)
5163 */
5164 MSVCRT_wint_t CDECL MSVCRT_ungetwc(MSVCRT_wint_t wc, MSVCRT_FILE * file)
5165 {
5166 MSVCRT_wint_t ret;
5167
5168 if(!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_WEOF;
5169
5170 MSVCRT__lock_file(file);
5171 ret = MSVCRT__ungetwc_nolock(wc, file);
5172 MSVCRT__unlock_file(file);
5173
5174 return ret;
5175 }
5176
5177 /*********************************************************************
5178 * _ungetwc_nolock (MSVCRT.@)
5179 */
5180 MSVCRT_wint_t CDECL MSVCRT__ungetwc_nolock(MSVCRT_wint_t wc, MSVCRT_FILE * file)
5181 {
5182 MSVCRT_wchar_t mwc = wc;
5183
5184 if(!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_WEOF;
5185 if (wc == MSVCRT_WEOF)
5186 return MSVCRT_WEOF;
5187
5188 if((get_ioinfo_nolock(file->_file)->exflag & (EF_UTF8 | EF_UTF16))
5189 || !(get_ioinfo_nolock(file->_file)->wxflag & WX_TEXT)) {
5190 unsigned char * pp = (unsigned char *)&mwc;
5191 int i;
5192
5193 for(i=sizeof(MSVCRT_wchar_t)-1;i>=0;i--) {
5194 if(pp[i] != MSVCRT__ungetc_nolock(pp[i],file))
5195 return MSVCRT_WEOF;
5196 }
5197 }else {
5198 char mbs[MSVCRT_MB_LEN_MAX];
5199 int len;
5200
5201 len = MSVCRT_wctomb(mbs, mwc);
5202 if(len == -1)
5203 return MSVCRT_WEOF;
5204
5205 for(len--; len>=0; len--) {
5206 if(mbs[len] != MSVCRT__ungetc_nolock(mbs[len], file))
5207 return MSVCRT_WEOF;
5208 }
5209 }
5210
5211 return mwc;
5212 }
5213
5214 /*********************************************************************
5215 * wprintf (MSVCRT.@)
5216 */
5217 int CDECL MSVCRT_wprintf(const MSVCRT_wchar_t *format, ...)
5218 {
5219 __ms_va_list valist;
5220 int res;
5221 __ms_va_start(valist, format);
5222 res = MSVCRT_vwprintf(format, valist);
5223 __ms_va_end(valist);
5224 return res;
5225 }
5226
5227 /*********************************************************************
5228 * wprintf_s (MSVCRT.@)
5229 */
5230 int CDECL MSVCRT_wprintf_s(const MSVCRT_wchar_t *format, ...)
5231 {
5232 __ms_va_list valist;
5233 int res;
5234 __ms_va_start(valist, format);
5235 res = MSVCRT_vwprintf_s(format, valist);
5236 __ms_va_end(valist);
5237 return res;
5238 }
5239
5240 /*********************************************************************
5241 * _getmaxstdio (MSVCRT.@)
5242 */
5243 int CDECL MSVCRT__getmaxstdio(void)
5244 {
5245 return MSVCRT_max_streams;
5246 }
5247
5248 /*********************************************************************
5249 * _setmaxstdio (MSVCRT.@)
5250 */
5251 int CDECL MSVCRT__setmaxstdio(int newmax)
5252 {
5253 TRACE("%d\n", newmax);
5254
5255 if(newmax<_IOB_ENTRIES || newmax>MSVCRT_MAX_FILES || newmax<MSVCRT_stream_idx)
5256 return -1;
5257
5258 MSVCRT_max_streams = newmax;
5259 return MSVCRT_max_streams;
5260 }
Maarten's multimedia branch