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