msvcrt: Fix file mode T (temporary file).
[wine] / dlls / msvcrt / dir.c
1 /*
2  * msvcrt.dll drive/directory 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  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22  */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <stdarg.h>
28 #include <time.h>
29
30 #include "windef.h"
31 #include "winbase.h"
32 #include "winternl.h"
33 #include "wine/unicode.h"
34 #include "msvcrt.h"
35 #include "wine/debug.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
38
39 /* INTERNAL: Translate WIN32_FIND_DATAA to finddata_t  */
40 static void msvcrt_fttofd( const WIN32_FIND_DATAA *fd, struct MSVCRT__finddata_t* ft)
41 {
42   DWORD dw;
43
44   if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
45     ft->attrib = 0;
46   else
47     ft->attrib = fd->dwFileAttributes;
48
49   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw );
50   ft->time_create = dw;
51   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
52   ft->time_access = dw;
53   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
54   ft->time_write = dw;
55   ft->size = fd->nFileSizeLow;
56   strcpy(ft->name, fd->cFileName);
57 }
58
59 /* INTERNAL: Translate WIN32_FIND_DATAA to finddata32_t  */
60 static void msvcrt_fttofd32( const WIN32_FIND_DATAA *fd, struct MSVCRT__finddata32_t* ft)
61 {
62   DWORD dw;
63
64   if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
65     ft->attrib = 0;
66   else
67     ft->attrib = fd->dwFileAttributes;
68
69   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw );
70   ft->time_create = dw;
71   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
72   ft->time_access = dw;
73   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
74   ft->time_write = dw;
75   ft->size = fd->nFileSizeLow;
76   strcpy(ft->name, fd->cFileName);
77 }
78
79 /* INTERNAL: Translate WIN32_FIND_DATAW to wfinddata_t  */
80 static void msvcrt_wfttofd( const WIN32_FIND_DATAW *fd, struct MSVCRT__wfinddata_t* ft)
81 {
82   DWORD dw;
83
84   if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
85     ft->attrib = 0;
86   else
87     ft->attrib = fd->dwFileAttributes;
88
89   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw );
90   ft->time_create = dw;
91   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
92   ft->time_access = dw;
93   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
94   ft->time_write = dw;
95   ft->size = fd->nFileSizeLow;
96   strcpyW(ft->name, fd->cFileName);
97 }
98
99 /* INTERNAL: Translate WIN32_FIND_DATAA to finddatai64_t  */
100 static void msvcrt_fttofdi64( const WIN32_FIND_DATAA *fd, struct MSVCRT__finddatai64_t* ft)
101 {
102   DWORD dw;
103
104   if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
105     ft->attrib = 0;
106   else
107     ft->attrib = fd->dwFileAttributes;
108
109   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw );
110   ft->time_create = dw;
111   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
112   ft->time_access = dw;
113   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
114   ft->time_write = dw;
115   ft->size = ((__int64)fd->nFileSizeHigh) << 32 | fd->nFileSizeLow;
116   strcpy(ft->name, fd->cFileName);
117 }
118
119 /* INTERNAL: Translate WIN32_FIND_DATAA to finddata64_t  */
120 static void msvcrt_fttofd64( const WIN32_FIND_DATAA *fd, struct MSVCRT__finddata64_t* ft)
121 {
122   DWORD dw;
123
124   if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
125     ft->attrib = 0;
126   else
127     ft->attrib = fd->dwFileAttributes;
128
129   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw );
130   ft->time_create = dw;
131   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
132   ft->time_access = dw;
133   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
134   ft->time_write = dw;
135   ft->size = ((__int64)fd->nFileSizeHigh) << 32 | fd->nFileSizeLow;
136   strcpy(ft->name, fd->cFileName);
137 }
138
139 /* INTERNAL: Translate WIN32_FIND_DATAW to wfinddata64_t  */
140 static void msvcrt_wfttofd64( const WIN32_FIND_DATAW *fd, struct MSVCRT__wfinddata64_t* ft)
141 {
142   DWORD dw;
143
144   if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
145     ft->attrib = 0;
146   else
147     ft->attrib = fd->dwFileAttributes;
148
149   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw );
150   ft->time_create = dw;
151   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
152   ft->time_access = dw;
153   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
154   ft->time_write = dw;
155   ft->size = ((__int64)fd->nFileSizeHigh) << 32 | fd->nFileSizeLow;
156   strcpyW(ft->name, fd->cFileName);
157 }
158
159 /* INTERNAL: Translate WIN32_FIND_DATAA to finddata64i32_t  */
160 static void msvcrt_fttofd64i32( const WIN32_FIND_DATAA *fd, struct MSVCRT__finddata64i32_t* ft)
161 {
162   DWORD dw;
163
164   if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
165     ft->attrib = 0;
166   else
167     ft->attrib = fd->dwFileAttributes;
168
169   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw );
170   ft->time_create = dw;
171   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
172   ft->time_access = dw;
173   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
174   ft->time_write = dw;
175   ft->size = fd->nFileSizeLow;
176   strcpy(ft->name, fd->cFileName);
177 }
178
179 /* INTERNAL: Translate WIN32_FIND_DATAW to wfinddatai64_t  */
180 static void msvcrt_wfttofdi64( const WIN32_FIND_DATAW *fd, struct MSVCRT__wfinddatai64_t* ft)
181 {
182   DWORD dw;
183
184   if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
185     ft->attrib = 0;
186   else
187     ft->attrib = fd->dwFileAttributes;
188
189   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw );
190   ft->time_create = dw;
191   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
192   ft->time_access = dw;
193   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
194   ft->time_write = dw;
195   ft->size = ((__int64)fd->nFileSizeHigh) << 32 | fd->nFileSizeLow;
196   strcpyW(ft->name, fd->cFileName);
197 }
198
199 /* INTERNAL: Translate WIN32_FIND_DATAW to wfinddata64i32_t  */
200 static void msvcrt_wfttofd64i32( const WIN32_FIND_DATAW *fd, struct MSVCRT__wfinddata64i32_t* ft)
201 {
202   DWORD dw;
203
204   if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
205     ft->attrib = 0;
206   else
207     ft->attrib = fd->dwFileAttributes;
208
209   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw );
210   ft->time_create = dw;
211   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
212   ft->time_access = dw;
213   RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
214   ft->time_write = dw;
215   ft->size = fd->nFileSizeLow;
216   strcpyW(ft->name, fd->cFileName);
217 }
218
219 /*********************************************************************
220  *              _chdir (MSVCRT.@)
221  *
222  * Change the current working directory.
223  *
224  * PARAMS
225  *  newdir [I] Directory to change to
226  *
227  * RETURNS
228  *  Success: 0. The current working directory is set to newdir.
229  *  Failure: -1. errno indicates the error.
230  *
231  * NOTES
232  *  See SetCurrentDirectoryA.
233  */
234 int CDECL MSVCRT__chdir(const char * newdir)
235 {
236   if (!SetCurrentDirectoryA(newdir))
237   {
238     msvcrt_set_errno(newdir?GetLastError():0);
239     return -1;
240   }
241   return 0;
242 }
243
244 /*********************************************************************
245  *              _wchdir (MSVCRT.@)
246  *
247  * Unicode version of _chdir.
248  */
249 int CDECL MSVCRT__wchdir(const MSVCRT_wchar_t * newdir)
250 {
251   if (!SetCurrentDirectoryW(newdir))
252   {
253     msvcrt_set_errno(newdir?GetLastError():0);
254     return -1;
255   }
256   return 0;
257 }
258
259 /*********************************************************************
260  *              _chdrive (MSVCRT.@)
261  *
262  * Change the current drive.
263  *
264  * PARAMS
265  *  newdrive [I] Drive number to change to (1 = 'A', 2 = 'B', ...)
266  *
267  * RETURNS
268  *  Success: 0. The current drive is set to newdrive.
269  *  Failure: -1. errno indicates the error.
270  *
271  * NOTES
272  *  See SetCurrentDirectoryA.
273  */
274 int CDECL MSVCRT__chdrive(int newdrive)
275 {
276   WCHAR buffer[] = {'A', ':', 0};
277
278   buffer[0] += newdrive - 1;
279   if (!SetCurrentDirectoryW( buffer ))
280   {
281     msvcrt_set_errno(GetLastError());
282     if (newdrive <= 0)
283       *MSVCRT__errno() = MSVCRT_EACCES;
284     return -1;
285   }
286   return 0;
287 }
288
289 /*********************************************************************
290  *              _findclose (MSVCRT.@)
291  *
292  * Close a handle returned by _findfirst().
293  *
294  * PARAMS
295  *  hand [I] Handle to close
296  *
297  * RETURNS
298  *  Success: 0. All resources associated with hand are freed.
299  *  Failure: -1. errno indicates the error.
300  *
301  * NOTES
302  *  See FindClose.
303  */
304 int CDECL MSVCRT__findclose(MSVCRT_intptr_t hand)
305 {
306   TRACE(":handle %ld\n",hand);
307   if (!FindClose((HANDLE)hand))
308   {
309     msvcrt_set_errno(GetLastError());
310     return -1;
311   }
312   return 0;
313 }
314
315 /*********************************************************************
316  *              _findfirst (MSVCRT.@)
317  *
318  * Open a handle for iterating through a directory.
319  *
320  * PARAMS
321  *  fspec [I] File specification of files to iterate.
322  *  ft    [O] Information for the first file found.
323  *
324  * RETURNS
325  *  Success: A handle suitable for passing to _findnext() and _findclose().
326  *           ft is populated with the details of the found file.
327  *  Failure: -1. errno indicates the error.
328  *
329  * NOTES
330  *  See FindFirstFileA.
331  */
332 MSVCRT_intptr_t CDECL MSVCRT__findfirst(const char * fspec, struct MSVCRT__finddata_t* ft)
333 {
334   WIN32_FIND_DATAA find_data;
335   HANDLE hfind;
336
337   hfind  = FindFirstFileA(fspec, &find_data);
338   if (hfind == INVALID_HANDLE_VALUE)
339   {
340     msvcrt_set_errno(GetLastError());
341     return -1;
342   }
343   msvcrt_fttofd(&find_data,ft);
344   TRACE(":got handle %p\n",hfind);
345   return (MSVCRT_intptr_t)hfind;
346 }
347
348 /*********************************************************************
349  *              _findfirst32 (MSVCRT.@)
350  */
351 MSVCRT_intptr_t CDECL MSVCRT__findfirst32(const char * fspec, struct MSVCRT__finddata32_t* ft)
352 {
353   WIN32_FIND_DATAA find_data;
354   HANDLE hfind;
355
356   hfind  = FindFirstFileA(fspec, &find_data);
357   if (hfind == INVALID_HANDLE_VALUE)
358   {
359     msvcrt_set_errno(GetLastError());
360     return -1;
361   }
362   msvcrt_fttofd32(&find_data, ft);
363   TRACE(":got handle %p\n", hfind);
364   return (MSVCRT_intptr_t)hfind;
365 }
366
367 /*********************************************************************
368  *              _wfindfirst (MSVCRT.@)
369  *
370  * Unicode version of _findfirst.
371  */
372 MSVCRT_intptr_t CDECL MSVCRT__wfindfirst(const MSVCRT_wchar_t * fspec, struct MSVCRT__wfinddata_t* ft)
373 {
374   WIN32_FIND_DATAW find_data;
375   HANDLE hfind;
376
377   hfind  = FindFirstFileW(fspec, &find_data);
378   if (hfind == INVALID_HANDLE_VALUE)
379   {
380     msvcrt_set_errno(GetLastError());
381     return -1;
382   }
383   msvcrt_wfttofd(&find_data,ft);
384   TRACE(":got handle %p\n",hfind);
385   return (MSVCRT_intptr_t)hfind;
386 }
387
388 /*********************************************************************
389  *              _findfirsti64 (MSVCRT.@)
390  *
391  * 64-bit version of _findfirst.
392  */
393 MSVCRT_intptr_t CDECL MSVCRT__findfirsti64(const char * fspec, struct MSVCRT__finddatai64_t* ft)
394 {
395   WIN32_FIND_DATAA find_data;
396   HANDLE hfind;
397
398   hfind  = FindFirstFileA(fspec, &find_data);
399   if (hfind == INVALID_HANDLE_VALUE)
400   {
401     msvcrt_set_errno(GetLastError());
402     return -1;
403   }
404   msvcrt_fttofdi64(&find_data,ft);
405   TRACE(":got handle %p\n",hfind);
406   return (MSVCRT_intptr_t)hfind;
407 }
408
409 /*********************************************************************
410  *              _findfirst64 (MSVCRT.@)
411  *
412  * 64-bit version of _findfirst.
413  */
414 MSVCRT_intptr_t CDECL MSVCRT__findfirst64(const char * fspec, struct MSVCRT__finddata64_t* ft)
415 {
416   WIN32_FIND_DATAA find_data;
417   HANDLE hfind;
418
419   hfind  = FindFirstFileA(fspec, &find_data);
420   if (hfind == INVALID_HANDLE_VALUE)
421   {
422     msvcrt_set_errno(GetLastError());
423     return -1;
424   }
425   msvcrt_fttofd64(&find_data,ft);
426   TRACE(":got handle %p\n",hfind);
427   return (MSVCRT_intptr_t)hfind;
428 }
429
430 /*********************************************************************
431  *              _wfindfirst64 (MSVCRT.@)
432  *
433  * Unicode version of _findfirst64.
434  */
435 MSVCRT_intptr_t CDECL MSVCRT__wfindfirst64(const MSVCRT_wchar_t * fspec, struct MSVCRT__wfinddata64_t* ft)
436 {
437   WIN32_FIND_DATAW find_data;
438   HANDLE hfind;
439
440   hfind  = FindFirstFileW(fspec, &find_data);
441   if (hfind == INVALID_HANDLE_VALUE)
442   {
443     msvcrt_set_errno(GetLastError());
444     return -1;
445   }
446   msvcrt_wfttofd64(&find_data,ft);
447   TRACE(":got handle %p\n",hfind);
448   return (MSVCRT_intptr_t)hfind;
449 }
450
451 /*********************************************************************
452  *              _findfirst64i32 (MSVCRT.@)
453  *
454  * 64-bit/32-bit version of _findfirst.
455  */
456 MSVCRT_intptr_t CDECL MSVCRT__findfirst64i32(const char * fspec, struct MSVCRT__finddata64i32_t* ft)
457 {
458   WIN32_FIND_DATAA find_data;
459   HANDLE hfind;
460
461   hfind  = FindFirstFileA(fspec, &find_data);
462   if (hfind == INVALID_HANDLE_VALUE)
463   {
464     msvcrt_set_errno(GetLastError());
465     return -1;
466   }
467   msvcrt_fttofd64i32(&find_data,ft);
468   TRACE(":got handle %p\n",hfind);
469   return (MSVCRT_intptr_t)hfind;
470 }
471
472 /*********************************************************************
473  *              _wfindfirst64i32 (MSVCRT.@)
474  *
475  * Unicode version of _findfirst64i32.
476  */
477 MSVCRT_intptr_t CDECL MSVCRT__wfindfirst64i32(const MSVCRT_wchar_t * fspec, struct MSVCRT__wfinddata64i32_t* ft)
478 {
479   WIN32_FIND_DATAW find_data;
480   HANDLE hfind;
481
482   hfind  = FindFirstFileW(fspec, &find_data);
483   if (hfind == INVALID_HANDLE_VALUE)
484   {
485     msvcrt_set_errno(GetLastError());
486     return -1;
487   }
488   msvcrt_wfttofd64i32(&find_data,ft);
489   TRACE(":got handle %p\n",hfind);
490   return (MSVCRT_intptr_t)hfind;
491 }
492
493 /*********************************************************************
494  *              _wfindfirsti64 (MSVCRT.@)
495  *
496  * Unicode version of _findfirsti64.
497  */
498 MSVCRT_intptr_t CDECL MSVCRT__wfindfirsti64(const MSVCRT_wchar_t * fspec, struct MSVCRT__wfinddatai64_t* ft)
499 {
500   WIN32_FIND_DATAW find_data;
501   HANDLE hfind;
502
503   hfind  = FindFirstFileW(fspec, &find_data);
504   if (hfind == INVALID_HANDLE_VALUE)
505   {
506     msvcrt_set_errno(GetLastError());
507     return -1;
508   }
509   msvcrt_wfttofdi64(&find_data,ft);
510   TRACE(":got handle %p\n",hfind);
511   return (MSVCRT_intptr_t)hfind;
512 }
513
514 /*********************************************************************
515  *              _findnext (MSVCRT.@)
516  *
517  * Find the next file from a file search handle.
518  *
519  * PARAMS
520  *  hand  [I] Handle to the search returned from _findfirst().
521  *  ft    [O] Information for the file found.
522  *
523  * RETURNS
524  *  Success: 0. ft is populated with the details of the found file.
525  *  Failure: -1. errno indicates the error.
526  *
527  * NOTES
528  *  See FindNextFileA.
529  */
530 int CDECL MSVCRT__findnext(MSVCRT_intptr_t hand, struct MSVCRT__finddata_t * ft)
531 {
532   WIN32_FIND_DATAA find_data;
533
534   if (!FindNextFileA((HANDLE)hand, &find_data))
535   {
536     *MSVCRT__errno() = MSVCRT_ENOENT;
537     return -1;
538   }
539
540   msvcrt_fttofd(&find_data,ft);
541   return 0;
542 }
543
544 /*********************************************************************
545  *               _findnext32 (MSVCRT.@)
546  */
547 int CDECL MSVCRT__findnext32(MSVCRT_intptr_t hand, struct MSVCRT__finddata32_t * ft)
548 {
549   WIN32_FIND_DATAA find_data;
550
551   if (!FindNextFileA((HANDLE)hand, &find_data))
552   {
553     *MSVCRT__errno() = MSVCRT_ENOENT;
554     return -1;
555   }
556
557   msvcrt_fttofd32(&find_data, ft);
558   return 0;
559 }
560
561 /*********************************************************************
562  *              _wfindnext (MSVCRT.@)
563  *
564  * Unicode version of _findnext.
565  */
566 int CDECL MSVCRT__wfindnext(MSVCRT_intptr_t hand, struct MSVCRT__wfinddata_t * ft)
567 {
568   WIN32_FIND_DATAW find_data;
569
570   if (!FindNextFileW((HANDLE)hand, &find_data))
571   {
572     *MSVCRT__errno() = MSVCRT_ENOENT;
573     return -1;
574   }
575
576   msvcrt_wfttofd(&find_data,ft);
577   return 0;
578 }
579
580 /*********************************************************************
581  *              _findnexti64 (MSVCRT.@)
582  *
583  * 64-bit version of _findnext.
584  */
585 int CDECL MSVCRT__findnexti64(MSVCRT_intptr_t hand, struct MSVCRT__finddatai64_t * ft)
586 {
587   WIN32_FIND_DATAA find_data;
588
589   if (!FindNextFileA((HANDLE)hand, &find_data))
590   {
591     *MSVCRT__errno() = MSVCRT_ENOENT;
592     return -1;
593   }
594
595   msvcrt_fttofdi64(&find_data,ft);
596   return 0;
597 }
598
599 /*********************************************************************
600  *              _findnext64 (MSVCRT.@)
601  *
602  * 64-bit version of _findnext.
603  */
604 int CDECL MSVCRT__findnext64(MSVCRT_intptr_t hand, struct MSVCRT__finddata64_t * ft)
605 {
606   WIN32_FIND_DATAA find_data;
607
608   if (!FindNextFileA((HANDLE)hand, &find_data))
609   {
610     *MSVCRT__errno() = MSVCRT_ENOENT;
611     return -1;
612   }
613
614   msvcrt_fttofd64(&find_data,ft);
615   return 0;
616 }
617
618 /*********************************************************************
619  *              _wfindnext64 (MSVCRT.@)
620  *
621  * Unicode version of _wfindnext64.
622  */
623 int CDECL MSVCRT__wfindnext64(MSVCRT_intptr_t hand, struct MSVCRT__wfinddata64_t * ft)
624 {
625   WIN32_FIND_DATAW find_data;
626
627   if (!FindNextFileW((HANDLE)hand, &find_data))
628   {
629     *MSVCRT__errno() = MSVCRT_ENOENT;
630     return -1;
631   }
632
633   msvcrt_wfttofd64(&find_data,ft);
634   return 0;
635 }
636
637 /*********************************************************************
638  *              _findnext64i32 (MSVCRT.@)
639  *
640  * 64-bit/32-bit version of _findnext.
641  */
642 int CDECL MSVCRT__findnext64i32(MSVCRT_intptr_t hand, struct MSVCRT__finddata64i32_t * ft)
643 {
644   WIN32_FIND_DATAA find_data;
645
646   if (!FindNextFileA((HANDLE)hand, &find_data))
647   {
648     *MSVCRT__errno() = MSVCRT_ENOENT;
649     return -1;
650   }
651
652   msvcrt_fttofd64i32(&find_data,ft);
653   return 0;
654 }
655
656 /*********************************************************************
657  *              _wfindnexti64 (MSVCRT.@)
658  *
659  * Unicode version of _findnexti64.
660  */
661 int CDECL MSVCRT__wfindnexti64(MSVCRT_intptr_t hand, struct MSVCRT__wfinddatai64_t * ft)
662 {
663   WIN32_FIND_DATAW find_data;
664
665   if (!FindNextFileW((HANDLE)hand, &find_data))
666   {
667     *MSVCRT__errno() = MSVCRT_ENOENT;
668     return -1;
669   }
670
671   msvcrt_wfttofdi64(&find_data,ft);
672   return 0;
673 }
674
675 /*********************************************************************
676  *              _wfindnext64i32 (MSVCRT.@)
677  *
678  * Unicode version of _findnext64i32.
679  */
680 int CDECL MSVCRT__wfindnext64i32(MSVCRT_intptr_t hand, struct MSVCRT__wfinddata64i32_t * ft)
681 {
682   WIN32_FIND_DATAW find_data;
683
684   if (!FindNextFileW((HANDLE)hand, &find_data))
685   {
686     *MSVCRT__errno() = MSVCRT_ENOENT;
687     return -1;
688   }
689
690   msvcrt_wfttofd64i32(&find_data,ft);
691   return 0;
692 }
693
694 /*********************************************************************
695  *              _getcwd (MSVCRT.@)
696  *
697  * Get the current working directory.
698  *
699  * PARAMS
700  *  buf  [O] Destination for current working directory.
701  *  size [I] Size of buf in characters
702  *
703  * RETURNS
704  * Success: If buf is NULL, returns an allocated string containing the path.
705  *          Otherwise populates buf with the path and returns it.
706  * Failure: NULL. errno indicates the error.
707  */
708 char* CDECL MSVCRT__getcwd(char * buf, int size)
709 {
710   char dir[MAX_PATH];
711   int dir_len = GetCurrentDirectoryA(MAX_PATH,dir);
712
713   if (dir_len < 1)
714     return NULL; /* FIXME: Real return value untested */
715
716   if (!buf)
717   {
718       if (size <= dir_len) size = dir_len + 1;
719       if (!(buf = MSVCRT_malloc( size ))) return NULL;
720   }
721   else if (dir_len >= size)
722   {
723     *MSVCRT__errno() = MSVCRT_ERANGE;
724     return NULL; /* buf too small */
725   }
726   strcpy(buf,dir);
727   return buf;
728 }
729
730 /*********************************************************************
731  *              _wgetcwd (MSVCRT.@)
732  *
733  * Unicode version of _getcwd.
734  */
735 MSVCRT_wchar_t* CDECL MSVCRT__wgetcwd(MSVCRT_wchar_t * buf, int size)
736 {
737   MSVCRT_wchar_t dir[MAX_PATH];
738   int dir_len = GetCurrentDirectoryW(MAX_PATH,dir);
739
740   if (dir_len < 1)
741     return NULL; /* FIXME: Real return value untested */
742
743   if (!buf)
744   {
745       if (size <= dir_len) size = dir_len + 1;
746       if (!(buf = MSVCRT_malloc( size * sizeof(WCHAR) ))) return NULL;
747   }
748   if (dir_len >= size)
749   {
750     *MSVCRT__errno() = MSVCRT_ERANGE;
751     return NULL; /* buf too small */
752   }
753   strcpyW(buf,dir);
754   return buf;
755 }
756
757 /*********************************************************************
758  *              _getdrive (MSVCRT.@)
759  *
760  * Get the current drive number.
761  *
762  * PARAMS
763  *  None.
764  *
765  * RETURNS
766  *  Success: The drive letter number from 1 to 26 ("A:" to "Z:").
767  *  Failure: 0.
768  */
769 int CDECL MSVCRT__getdrive(void)
770 {
771     WCHAR buffer[MAX_PATH];
772     if (GetCurrentDirectoryW( MAX_PATH, buffer ) &&
773         buffer[0] >= 'A' && buffer[0] <= 'z' && buffer[1] == ':')
774         return toupperW(buffer[0]) - 'A' + 1;
775     return 0;
776 }
777
778 /*********************************************************************
779  *              _getdcwd (MSVCRT.@)
780  *
781  * Get the current working directory on a given disk.
782  * 
783  * PARAMS
784  *  drive [I] Drive letter to get the current working directory from.
785  *  buf   [O] Destination for the current working directory.
786  *  size  [I] Length of drive in characters.
787  *
788  * RETURNS
789  *  Success: If drive is NULL, returns an allocated string containing the path.
790  *           Otherwise populates drive with the path and returns it.
791  *  Failure: NULL. errno indicates the error.
792  */
793 char* CDECL MSVCRT__getdcwd(int drive, char * buf, int size)
794 {
795   static char* dummy;
796
797   TRACE(":drive %d(%c), size %d\n",drive, drive + 'A' - 1, size);
798
799   if (!drive || drive == MSVCRT__getdrive())
800     return MSVCRT__getcwd(buf,size); /* current */
801   else
802   {
803     char dir[MAX_PATH];
804     char drivespec[] = {'A', ':', 0};
805     int dir_len;
806
807     drivespec[0] += drive - 1;
808     if (GetDriveTypeA(drivespec) < DRIVE_REMOVABLE)
809     {
810       *MSVCRT__errno() = MSVCRT_EACCES;
811       return NULL;
812     }
813
814     dir_len = GetFullPathNameA(drivespec,MAX_PATH,dir,&dummy);
815     if (dir_len >= size || dir_len < 1)
816     {
817       *MSVCRT__errno() = MSVCRT_ERANGE;
818       return NULL; /* buf too small */
819     }
820
821     TRACE(":returning '%s'\n", dir);
822     if (!buf)
823       return MSVCRT__strdup(dir); /* allocate */
824
825     strcpy(buf,dir);
826   }
827   return buf;
828 }
829
830 /*********************************************************************
831  *              _wgetdcwd (MSVCRT.@)
832  *
833  * Unicode version of _wgetdcwd.
834  */
835 MSVCRT_wchar_t* CDECL MSVCRT__wgetdcwd(int drive, MSVCRT_wchar_t * buf, int size)
836 {
837   static MSVCRT_wchar_t* dummy;
838
839   TRACE(":drive %d(%c), size %d\n",drive, drive + 'A' - 1, size);
840
841   if (!drive || drive == MSVCRT__getdrive())
842     return MSVCRT__wgetcwd(buf,size); /* current */
843   else
844   {
845     MSVCRT_wchar_t dir[MAX_PATH];
846     MSVCRT_wchar_t drivespec[4] = {'A', ':', '\\', 0};
847     int dir_len;
848
849     drivespec[0] += drive - 1;
850     if (GetDriveTypeW(drivespec) < DRIVE_REMOVABLE)
851     {
852       *MSVCRT__errno() = MSVCRT_EACCES;
853       return NULL;
854     }
855
856     dir_len = GetFullPathNameW(drivespec,MAX_PATH,dir,&dummy);
857     if (dir_len >= size || dir_len < 1)
858     {
859       *MSVCRT__errno() = MSVCRT_ERANGE;
860       return NULL; /* buf too small */
861     }
862
863     TRACE(":returning %s\n", debugstr_w(dir));
864     if (!buf)
865       return MSVCRT__wcsdup(dir); /* allocate */
866     strcpyW(buf,dir);
867   }
868   return buf;
869 }
870
871 /*********************************************************************
872  *              _getdiskfree (MSVCRT.@)
873  *
874  * Get information about the free space on a drive.
875  *
876  * PARAMS
877  *  disk [I] Drive number to get information about (1 = 'A', 2 = 'B', ...)
878  *  info [O] Destination for the resulting information.
879  *
880  * RETURNS
881  *  Success: 0. info is updated with the free space information.
882  *  Failure: An error code from GetLastError().
883  *
884  * NOTES
885  *  See GetLastError().
886  */
887 unsigned int CDECL MSVCRT__getdiskfree(unsigned int disk, struct MSVCRT__diskfree_t * d)
888 {
889   WCHAR drivespec[] = {'@', ':', '\\', 0};
890   DWORD ret[4];
891   unsigned int err;
892
893   if (disk > 26)
894     return ERROR_INVALID_PARAMETER; /* MSVCRT doesn't set errno here */
895
896   drivespec[0] += disk; /* make a drive letter */
897
898   if (GetDiskFreeSpaceW(disk==0?NULL:drivespec,ret,ret+1,ret+2,ret+3))
899   {
900     d->sectors_per_cluster = ret[0];
901     d->bytes_per_sector = ret[1];
902     d->avail_clusters = ret[2];
903     d->total_clusters = ret[3];
904     return 0;
905   }
906   err = GetLastError();
907   msvcrt_set_errno(err);
908   return err;
909 }
910
911 /*********************************************************************
912  *              _mkdir (MSVCRT.@)
913  *
914  * Create a directory.
915  *
916  * PARAMS
917  *  newdir [I] Name of directory to create.
918  *
919  * RETURNS
920  *  Success: 0. The directory indicated by newdir is created.
921  *  Failure: -1. errno indicates the error.
922  *
923  * NOTES
924  *  See CreateDirectoryA.
925  */
926 int CDECL MSVCRT__mkdir(const char * newdir)
927 {
928   if (CreateDirectoryA(newdir,NULL))
929     return 0;
930   msvcrt_set_errno(GetLastError());
931   return -1;
932 }
933
934 /*********************************************************************
935  *              _wmkdir (MSVCRT.@)
936  *
937  * Unicode version of _mkdir.
938  */
939 int CDECL MSVCRT__wmkdir(const MSVCRT_wchar_t* newdir)
940 {
941   if (CreateDirectoryW(newdir,NULL))
942     return 0;
943   msvcrt_set_errno(GetLastError());
944   return -1;
945 }
946
947 /*********************************************************************
948  *              _rmdir (MSVCRT.@)
949  *
950  * Delete a directory.
951  *
952  * PARAMS
953  *  dir [I] Name of directory to delete.
954  *
955  * RETURNS
956  *  Success: 0. The directory indicated by newdir is deleted.
957  *  Failure: -1. errno indicates the error.
958  *
959  * NOTES
960  *  See RemoveDirectoryA.
961  */
962 int CDECL MSVCRT__rmdir(const char * dir)
963 {
964   if (RemoveDirectoryA(dir))
965     return 0;
966   msvcrt_set_errno(GetLastError());
967   return -1;
968 }
969
970 /*********************************************************************
971  *              _wrmdir (MSVCRT.@)
972  *
973  * Unicode version of _rmdir.
974  */
975 int CDECL MSVCRT__wrmdir(const MSVCRT_wchar_t * dir)
976 {
977   if (RemoveDirectoryW(dir))
978     return 0;
979   msvcrt_set_errno(GetLastError());
980   return -1;
981 }
982
983 /******************************************************************
984  *              _splitpath_s (MSVCRT.@)
985  */
986 int CDECL _splitpath_s(const char* inpath,
987         char* drive, MSVCRT_size_t sz_drive,
988         char* dir, MSVCRT_size_t sz_dir,
989         char* fname, MSVCRT_size_t sz_fname,
990         char* ext, MSVCRT_size_t sz_ext)
991 {
992     const char *p, *end;
993
994     if (!inpath || (!drive && sz_drive) ||
995             (drive && !sz_drive) ||
996             (!dir && sz_dir) ||
997             (dir && !sz_dir) ||
998             (!fname && sz_fname) ||
999             (fname && !sz_fname) ||
1000             (!ext && sz_ext) ||
1001             (ext && !sz_ext))
1002     {
1003         *MSVCRT__errno() = MSVCRT_EINVAL;
1004         return MSVCRT_EINVAL;
1005     }
1006
1007     if (inpath[0] && inpath[1] == ':')
1008     {
1009         if (drive)
1010         {
1011             if (sz_drive <= 2) goto do_error;
1012             drive[0] = inpath[0];
1013             drive[1] = inpath[1];
1014             drive[2] = 0;
1015         }
1016         inpath += 2;
1017     }
1018     else if (drive) drive[0] = '\0';
1019
1020     /* look for end of directory part */
1021     end = NULL;
1022     for (p = inpath; *p; p++) if (*p == '/' || *p == '\\') end = p + 1;
1023
1024     if (end)  /* got a directory */
1025     {
1026         if (dir)
1027         {
1028             if (sz_dir <= end - inpath) goto do_error;
1029             memcpy( dir, inpath, (end - inpath) );
1030             dir[end - inpath] = 0;
1031         }
1032         inpath = end;
1033     }
1034     else if (dir) dir[0] = 0;
1035
1036     /* look for extension: what's after the last dot */
1037     end = NULL;
1038     for (p = inpath; *p; p++) if (*p == '.') end = p;
1039
1040     if (!end) end = p; /* there's no extension */
1041
1042     if (fname)
1043     {
1044         if (sz_fname <= end - inpath) goto do_error;
1045         memcpy( fname, inpath, (end - inpath) );
1046         fname[end - inpath] = 0;
1047     }
1048     if (ext)
1049     {
1050         if (sz_ext <= strlen(end)) goto do_error;
1051         strcpy( ext, end );
1052     }
1053     return 0;
1054 do_error:
1055     if (drive)  drive[0] = '\0';
1056     if (dir)    dir[0] = '\0';
1057     if (fname)  fname[0]= '\0';
1058     if (ext)    ext[0]= '\0';
1059     *MSVCRT__errno() = MSVCRT_ERANGE;
1060     return MSVCRT_ERANGE;
1061 }
1062
1063 /*********************************************************************
1064  *              _splitpath (MSVCRT.@)
1065  */
1066 void CDECL _splitpath(const char *inpath, char *drv, char *dir,
1067         char *fname, char *ext)
1068 {
1069     _splitpath_s(inpath, drv, drv?MSVCRT__MAX_DRIVE:0, dir, dir?MSVCRT__MAX_DIR:0,
1070             fname, fname?MSVCRT__MAX_FNAME:0, ext, ext?MSVCRT__MAX_EXT:0);
1071 }
1072
1073 /******************************************************************
1074  *              _wsplitpath_s (MSVCRT.@)
1075  *
1076  * Secure version of _wsplitpath
1077  */
1078 int CDECL _wsplitpath_s(const MSVCRT_wchar_t* inpath,
1079                   MSVCRT_wchar_t* drive, MSVCRT_size_t sz_drive,
1080                   MSVCRT_wchar_t* dir, MSVCRT_size_t sz_dir,
1081                   MSVCRT_wchar_t* fname, MSVCRT_size_t sz_fname,
1082                   MSVCRT_wchar_t* ext, MSVCRT_size_t sz_ext)
1083 {
1084     const MSVCRT_wchar_t *p, *end;
1085
1086     if (!inpath || (!drive && sz_drive) ||
1087             (drive && !sz_drive) ||
1088             (!dir && sz_dir) ||
1089             (dir && !sz_dir) ||
1090             (!fname && sz_fname) ||
1091             (fname && !sz_fname) ||
1092             (!ext && sz_ext) ||
1093             (ext && !sz_ext))
1094     {
1095         *MSVCRT__errno() = MSVCRT_EINVAL;
1096         return MSVCRT_EINVAL;
1097     }
1098
1099     if (inpath[0] && inpath[1] == ':')
1100     {
1101         if (drive)
1102         {
1103             if (sz_drive <= 2) goto do_error;
1104             drive[0] = inpath[0];
1105             drive[1] = inpath[1];
1106             drive[2] = 0;
1107         }
1108         inpath += 2;
1109     }
1110     else if (drive) drive[0] = '\0';
1111
1112     /* look for end of directory part */
1113     end = NULL;
1114     for (p = inpath; *p; p++) if (*p == '/' || *p == '\\') end = p + 1;
1115
1116     if (end)  /* got a directory */
1117     {
1118         if (dir)
1119         {
1120             if (sz_dir <= end - inpath) goto do_error;
1121             memcpy( dir, inpath, (end - inpath) * sizeof(MSVCRT_wchar_t) );
1122             dir[end - inpath] = 0;
1123         }
1124         inpath = end;
1125     }
1126     else if (dir) dir[0] = 0;
1127
1128     /* look for extension: what's after the last dot */
1129     end = NULL;
1130     for (p = inpath; *p; p++) if (*p == '.') end = p;
1131
1132     if (!end) end = p; /* there's no extension */
1133
1134     if (fname)
1135     {
1136         if (sz_fname <= end - inpath) goto do_error;
1137         memcpy( fname, inpath, (end - inpath) * sizeof(MSVCRT_wchar_t) );
1138         fname[end - inpath] = 0;
1139     }
1140     if (ext)
1141     {
1142         if (sz_ext <= strlenW(end)) goto do_error;
1143         strcpyW( ext, end );
1144     }
1145     return 0;
1146 do_error:
1147     if (drive)  drive[0] = '\0';
1148     if (dir)    dir[0] = '\0';
1149     if (fname)  fname[0]= '\0';
1150     if (ext)    ext[0]= '\0';
1151     *MSVCRT__errno() = MSVCRT_ERANGE;
1152     return MSVCRT_ERANGE;
1153 }
1154
1155 /*********************************************************************
1156  *              _wsplitpath (MSVCRT.@)
1157  *
1158  * Unicode version of _splitpath.
1159  */
1160 void CDECL _wsplitpath(const MSVCRT_wchar_t *inpath, MSVCRT_wchar_t *drv, MSVCRT_wchar_t *dir,
1161         MSVCRT_wchar_t *fname, MSVCRT_wchar_t *ext)
1162 {
1163     _wsplitpath_s(inpath, drv, drv?MSVCRT__MAX_DRIVE:0, dir, dir?MSVCRT__MAX_DIR:0,
1164             fname, fname?MSVCRT__MAX_FNAME:0, ext, ext?MSVCRT__MAX_EXT:0);
1165 }
1166
1167 /*********************************************************************
1168  *              _wfullpath (MSVCRT.@)
1169  *
1170  * Unicode version of _fullpath.
1171  */
1172 MSVCRT_wchar_t * CDECL _wfullpath(MSVCRT_wchar_t * absPath, const MSVCRT_wchar_t* relPath, MSVCRT_size_t size)
1173 {
1174   DWORD rc;
1175   WCHAR* buffer;
1176   WCHAR* lastpart;
1177   BOOL alloced = FALSE;
1178
1179   if (!relPath || !*relPath)
1180     return MSVCRT__wgetcwd(absPath, size);
1181
1182   if (absPath == NULL)
1183   {
1184       buffer = MSVCRT_malloc(MAX_PATH * sizeof(WCHAR));
1185       size = MAX_PATH;
1186       alloced = TRUE;
1187   }
1188   else
1189       buffer = absPath;
1190
1191   if (size < 4)
1192   {
1193     *MSVCRT__errno() = MSVCRT_ERANGE;
1194     return NULL;
1195   }
1196
1197   TRACE(":resolving relative path %s\n",debugstr_w(relPath));
1198
1199   rc = GetFullPathNameW(relPath,size,buffer,&lastpart);
1200
1201   if (rc > 0 && rc <= size )
1202     return buffer;
1203   else
1204   {
1205       if (alloced)
1206           MSVCRT_free(buffer);
1207         return NULL;
1208   }
1209 }
1210
1211 /*********************************************************************
1212  *              _fullpath (MSVCRT.@)
1213  *
1214  * Create an absolute path from a relative path.
1215  *
1216  * PARAMS
1217  *  absPath [O] Destination for absolute path
1218  *  relPath [I] Relative path to convert to absolute
1219  *  size    [I] Length of absPath in characters.
1220  *
1221  * RETURNS
1222  * Success: If absPath is NULL, returns an allocated string containing the path.
1223  *          Otherwise populates absPath with the path and returns it.
1224  * Failure: NULL. errno indicates the error.
1225  */
1226 char * CDECL _fullpath(char * absPath, const char* relPath, unsigned int size)
1227 {
1228   DWORD rc;
1229   char* lastpart;
1230   char* buffer;
1231   BOOL alloced = FALSE;
1232
1233   if (!relPath || !*relPath)
1234     return MSVCRT__getcwd(absPath, size);
1235
1236   if (absPath == NULL)
1237   {
1238       buffer = MSVCRT_malloc(MAX_PATH);
1239       size = MAX_PATH;
1240       alloced = TRUE;
1241   }
1242   else
1243       buffer = absPath;
1244
1245   if (size < 4)
1246   {
1247     *MSVCRT__errno() = MSVCRT_ERANGE;
1248     return NULL;
1249   }
1250
1251   TRACE(":resolving relative path '%s'\n",relPath);
1252
1253   rc = GetFullPathNameA(relPath,size,buffer,&lastpart);
1254
1255   if (rc > 0 && rc <= size)
1256     return buffer;
1257   else
1258   {
1259       if (alloced)
1260           MSVCRT_free(buffer);
1261         return NULL;
1262   }
1263 }
1264
1265 /*********************************************************************
1266  *              _makepath (MSVCRT.@)
1267  *
1268  * Create a pathname.
1269  *
1270  * PARAMS
1271  *  path      [O] Destination for created pathname
1272  *  drive     [I] Drive letter (e.g. "A:")
1273  *  directory [I] Directory
1274  *  filename  [I] Name of the file, excluding extension
1275  *  extension [I] File extension (e.g. ".TXT")
1276  *
1277  * RETURNS
1278  *  Nothing. If path is not large enough to hold the resulting pathname,
1279  *  random process memory will be overwritten.
1280  */
1281 VOID CDECL _makepath(char * path, const char * drive,
1282                      const char *directory, const char * filename,
1283                      const char * extension)
1284 {
1285     char *p = path;
1286
1287     TRACE("(%s %s %s %s)\n", debugstr_a(drive), debugstr_a(directory),
1288           debugstr_a(filename), debugstr_a(extension) );
1289
1290     if ( !path )
1291         return;
1292
1293     if (drive && drive[0])
1294     {
1295         *p++ = drive[0];
1296         *p++ = ':';
1297     }
1298     if (directory && directory[0])
1299     {
1300         unsigned int len = strlen(directory);
1301         memmove(p, directory, len);
1302         p += len;
1303         if (p[-1] != '/' && p[-1] != '\\')
1304             *p++ = '\\';
1305     }
1306     if (filename && filename[0])
1307     {
1308         unsigned int len = strlen(filename);
1309         memmove(p, filename, len);
1310         p += len;
1311     }
1312     if (extension && extension[0])
1313     {
1314         if (extension[0] != '.')
1315             *p++ = '.';
1316         strcpy(p, extension);
1317     }
1318     else
1319         *p = '\0';
1320     TRACE("returning %s\n",path);
1321 }
1322
1323 /*********************************************************************
1324  *              _wmakepath (MSVCRT.@)
1325  *
1326  * Unicode version of _wmakepath.
1327  */
1328 VOID CDECL _wmakepath(MSVCRT_wchar_t *path, const MSVCRT_wchar_t *drive, const MSVCRT_wchar_t *directory,
1329                       const MSVCRT_wchar_t *filename, const MSVCRT_wchar_t *extension)
1330 {
1331     MSVCRT_wchar_t *p = path;
1332
1333     TRACE("%s %s %s %s\n", debugstr_w(drive), debugstr_w(directory),
1334           debugstr_w(filename), debugstr_w(extension));
1335
1336     if ( !path )
1337         return;
1338
1339     if (drive && drive[0])
1340     {
1341         *p++ = drive[0];
1342         *p++ = ':';
1343     }
1344     if (directory && directory[0])
1345     {
1346         unsigned int len = strlenW(directory);
1347         memmove(p, directory, len * sizeof(MSVCRT_wchar_t));
1348         p += len;
1349         if (p[-1] != '/' && p[-1] != '\\')
1350             *p++ = '\\';
1351     }
1352     if (filename && filename[0])
1353     {
1354         unsigned int len = strlenW(filename);
1355         memmove(p, filename, len * sizeof(MSVCRT_wchar_t));
1356         p += len;
1357     }
1358     if (extension && extension[0])
1359     {
1360         if (extension[0] != '.')
1361             *p++ = '.';
1362         strcpyW(p, extension);
1363     }
1364     else
1365         *p = '\0';
1366
1367     TRACE("returning %s\n", debugstr_w(path));
1368 }
1369
1370 /*********************************************************************
1371  *              _makepath_s (MSVCRT.@)
1372  *
1373  * Safe version of _makepath.
1374  */
1375 int CDECL _makepath_s(char *path, MSVCRT_size_t size, const char *drive,
1376                       const char *directory, const char *filename,
1377                       const char *extension)
1378 {
1379     char *p = path;
1380
1381     if (!path || !size)
1382     {
1383         *MSVCRT__errno() = MSVCRT_EINVAL;
1384         return MSVCRT_EINVAL;
1385     }
1386
1387     if (drive && drive[0])
1388     {
1389         if (size <= 2)
1390             goto range;
1391
1392         *p++ = drive[0];
1393         *p++ = ':';
1394         size -= 2;
1395     }
1396
1397     if (directory && directory[0])
1398     {
1399         unsigned int len = strlen(directory);
1400         unsigned int needs_separator = directory[len - 1] != '/' && directory[len - 1] != '\\';
1401         unsigned int copylen = min(size - 1, len);
1402
1403         if (size < 2)
1404             goto range;
1405
1406         memmove(p, directory, copylen);
1407
1408         if (size <= len)
1409             goto range;
1410
1411         p += copylen;
1412         size -= copylen;
1413
1414         if (needs_separator)
1415         {
1416             if (size < 2)
1417                 goto range;
1418
1419             *p++ = '\\';
1420             size -= 1;
1421         }
1422     }
1423
1424     if (filename && filename[0])
1425     {
1426         unsigned int len = strlen(filename);
1427         unsigned int copylen = min(size - 1, len);
1428
1429         if (size < 2)
1430             goto range;
1431
1432         memmove(p, filename, copylen);
1433
1434         if (size <= len)
1435             goto range;
1436
1437         p += len;
1438         size -= len;
1439     }
1440
1441     if (extension && extension[0])
1442     {
1443         unsigned int len = strlen(extension);
1444         unsigned int needs_period = extension[0] != '.';
1445         unsigned int copylen;
1446
1447         if (size < 2)
1448             goto range;
1449
1450         if (needs_period)
1451         {
1452             *p++ = '.';
1453             size -= 1;
1454         }
1455
1456         copylen = min(size - 1, len);
1457         memcpy(p, extension, copylen);
1458
1459         if (size <= len)
1460             goto range;
1461
1462         p += copylen;
1463     }
1464
1465     *p = '\0';
1466     return 0;
1467
1468 range:
1469     path[0] = '\0';
1470     *MSVCRT__errno() = MSVCRT_ERANGE;
1471     return MSVCRT_ERANGE;
1472 }
1473
1474 /*********************************************************************
1475  *              _wmakepath_s (MSVCRT.@)
1476  *
1477  * Safe version of _wmakepath.
1478  */
1479 int CDECL _wmakepath_s(MSVCRT_wchar_t *path, MSVCRT_size_t size, const MSVCRT_wchar_t *drive,
1480                        const MSVCRT_wchar_t *directory, const MSVCRT_wchar_t *filename,
1481                        const MSVCRT_wchar_t *extension)
1482 {
1483     MSVCRT_wchar_t *p = path;
1484
1485     if (!path || !size)
1486     {
1487         *MSVCRT__errno() = MSVCRT_EINVAL;
1488         return MSVCRT_EINVAL;
1489     }
1490
1491     if (drive && drive[0])
1492     {
1493         if (size <= 2)
1494             goto range;
1495
1496         *p++ = drive[0];
1497         *p++ = ':';
1498         size -= 2;
1499     }
1500
1501     if (directory && directory[0])
1502     {
1503         unsigned int len = strlenW(directory);
1504         unsigned int needs_separator = directory[len - 1] != '/' && directory[len - 1] != '\\';
1505         unsigned int copylen = min(size - 1, len);
1506
1507         if (size < 2)
1508             goto range;
1509
1510         memmove(p, directory, copylen * sizeof(MSVCRT_wchar_t));
1511
1512         if (size <= len)
1513             goto range;
1514
1515         p += copylen;
1516         size -= copylen;
1517
1518         if (needs_separator)
1519         {
1520             if (size < 2)
1521                 goto range;
1522
1523             *p++ = '\\';
1524             size -= 1;
1525         }
1526     }
1527
1528     if (filename && filename[0])
1529     {
1530         unsigned int len = strlenW(filename);
1531         unsigned int copylen = min(size - 1, len);
1532
1533         if (size < 2)
1534             goto range;
1535
1536         memmove(p, filename, copylen * sizeof(MSVCRT_wchar_t));
1537
1538         if (size <= len)
1539             goto range;
1540
1541         p += len;
1542         size -= len;
1543     }
1544
1545     if (extension && extension[0])
1546     {
1547         unsigned int len = strlenW(extension);
1548         unsigned int needs_period = extension[0] != '.';
1549         unsigned int copylen;
1550
1551         if (size < 2)
1552             goto range;
1553
1554         if (needs_period)
1555         {
1556             *p++ = '.';
1557             size -= 1;
1558         }
1559
1560         copylen = min(size - 1, len);
1561         memcpy(p, extension, copylen * sizeof(MSVCRT_wchar_t));
1562
1563         if (size <= len)
1564             goto range;
1565
1566         p += copylen;
1567     }
1568
1569     *p = '\0';
1570     return 0;
1571
1572 range:
1573     path[0] = '\0';
1574     *MSVCRT__errno() = MSVCRT_ERANGE;
1575     return MSVCRT_ERANGE;
1576 }
1577
1578 /*********************************************************************
1579  *              _searchenv (MSVCRT.@)
1580  *
1581  * Search for a file in a list of paths from an environment variable.
1582  *
1583  * PARAMS
1584  *  file   [I] Name of the file to search for.
1585  *  env    [I] Name of the environment variable containing a list of paths.
1586  *  buf    [O] Destination for the found file path.
1587  *
1588  * RETURNS
1589  *  Nothing. If the file is not found, buf will contain an empty string
1590  *  and errno is set.
1591  */
1592 void CDECL MSVCRT__searchenv(const char* file, const char* env, char *buf)
1593 {
1594   char*envVal, *penv;
1595   char curPath[MAX_PATH];
1596
1597   *buf = '\0';
1598
1599   /* Try CWD first */
1600   if (GetFileAttributesA( file ) != INVALID_FILE_ATTRIBUTES)
1601   {
1602     GetFullPathNameA( file, MAX_PATH, buf, NULL );
1603     /* Sigh. This error is *always* set, regardless of success */
1604     msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
1605     return;
1606   }
1607
1608   /* Search given environment variable */
1609   envVal = MSVCRT_getenv(env);
1610   if (!envVal)
1611   {
1612     msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
1613     return;
1614   }
1615
1616   penv = envVal;
1617   TRACE(":searching for %s in paths %s\n", file, envVal);
1618
1619   do
1620   {
1621     char *end = penv;
1622
1623     while(*end && *end != ';') end++; /* Find end of next path */
1624     if (penv == end || !*penv)
1625     {
1626       msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
1627       return;
1628     }
1629     memcpy(curPath, penv, end - penv);
1630     if (curPath[end - penv] != '/' && curPath[end - penv] != '\\')
1631     {
1632       curPath[end - penv] = '\\';
1633       curPath[end - penv + 1] = '\0';
1634     }
1635     else
1636       curPath[end - penv] = '\0';
1637
1638     strcat(curPath, file);
1639     TRACE("Checking for file %s\n", curPath);
1640     if (GetFileAttributesA( curPath ) != INVALID_FILE_ATTRIBUTES)
1641     {
1642       strcpy(buf, curPath);
1643       msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
1644       return; /* Found */
1645     }
1646     penv = *end ? end + 1 : end;
1647   } while(1);
1648 }
1649
1650 /*********************************************************************
1651  *              _searchenv_s (MSVCRT.@)
1652  */
1653 int CDECL _searchenv_s(const char* file, const char* env, char *buf, MSVCRT_size_t count)
1654 {
1655   char*envVal, *penv;
1656   char curPath[MAX_PATH];
1657
1658   if (!MSVCRT_CHECK_PMT(file != NULL) || !MSVCRT_CHECK_PMT(buf != NULL) ||
1659       !MSVCRT_CHECK_PMT(count > 0))
1660   {
1661       *MSVCRT__errno() = MSVCRT_EINVAL;
1662       return MSVCRT_EINVAL;
1663   }
1664
1665   *buf = '\0';
1666
1667   /* Try CWD first */
1668   if (GetFileAttributesA( file ) != INVALID_FILE_ATTRIBUTES)
1669   {
1670     if (GetFullPathNameA( file, count, buf, NULL )) return 0;
1671     msvcrt_set_errno(GetLastError());
1672     return 0;
1673   }
1674
1675   /* Search given environment variable */
1676   envVal = MSVCRT_getenv(env);
1677   if (!envVal)
1678   {
1679     *MSVCRT__errno() = MSVCRT_ENOENT;
1680     return MSVCRT_ENOENT;
1681   }
1682
1683   penv = envVal;
1684   TRACE(":searching for %s in paths %s\n", file, envVal);
1685
1686   do
1687   {
1688     char *end = penv;
1689
1690     while(*end && *end != ';') end++; /* Find end of next path */
1691     if (penv == end || !*penv)
1692     {
1693       *MSVCRT__errno() = MSVCRT_ENOENT;
1694       return MSVCRT_ENOENT;
1695     }
1696     memcpy(curPath, penv, end - penv);
1697     if (curPath[end - penv] != '/' && curPath[end - penv] != '\\')
1698     {
1699       curPath[end - penv] = '\\';
1700       curPath[end - penv + 1] = '\0';
1701     }
1702     else
1703       curPath[end - penv] = '\0';
1704
1705     strcat(curPath, file);
1706     TRACE("Checking for file %s\n", curPath);
1707     if (GetFileAttributesA( curPath ) != INVALID_FILE_ATTRIBUTES)
1708     {
1709       if (strlen(curPath) + 1 > count)
1710       {
1711           MSVCRT_INVALID_PMT("buf[count] is too small");
1712           *MSVCRT__errno() = MSVCRT_ERANGE;
1713           return MSVCRT_ERANGE;
1714       }
1715       strcpy(buf, curPath);
1716       return 0;
1717     }
1718     penv = *end ? end + 1 : end;
1719   } while(1);
1720 }
1721
1722 /*********************************************************************
1723  *      _wsearchenv (MSVCRT.@)
1724  *
1725  * Unicode version of _searchenv
1726  */
1727 void CDECL MSVCRT__wsearchenv(const MSVCRT_wchar_t* file, const MSVCRT_wchar_t* env, MSVCRT_wchar_t *buf)
1728 {
1729   MSVCRT_wchar_t *envVal, *penv;
1730   MSVCRT_wchar_t curPath[MAX_PATH];
1731
1732   *buf = '\0';
1733
1734   /* Try CWD first */
1735   if (GetFileAttributesW( file ) != INVALID_FILE_ATTRIBUTES)
1736   {
1737     GetFullPathNameW( file, MAX_PATH, buf, NULL );
1738     /* Sigh. This error is *always* set, regardless of success */
1739     msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
1740     return;
1741   }
1742
1743   /* Search given environment variable */
1744   envVal = MSVCRT__wgetenv(env);
1745   if (!envVal)
1746   {
1747     msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
1748     return;
1749   }
1750
1751   penv = envVal;
1752   TRACE(":searching for %s in paths %s\n", debugstr_w(file), debugstr_w(envVal));
1753
1754   do
1755   {
1756     MSVCRT_wchar_t *end = penv;
1757
1758     while(*end && *end != ';') end++; /* Find end of next path */
1759     if (penv == end || !*penv)
1760     {
1761       msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
1762       return;
1763     }
1764     memcpy(curPath, penv, (end - penv) * sizeof(MSVCRT_wchar_t));
1765     if (curPath[end - penv] != '/' && curPath[end - penv] != '\\')
1766     {
1767       curPath[end - penv] = '\\';
1768       curPath[end - penv + 1] = '\0';
1769     }
1770     else
1771       curPath[end - penv] = '\0';
1772
1773     strcatW(curPath, file);
1774     TRACE("Checking for file %s\n", debugstr_w(curPath));
1775     if (GetFileAttributesW( curPath ) != INVALID_FILE_ATTRIBUTES)
1776     {
1777       strcpyW(buf, curPath);
1778       msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
1779       return; /* Found */
1780     }
1781     penv = *end ? end + 1 : end;
1782   } while(1);
1783 }
1784
1785 /*********************************************************************
1786  *              _wsearchenv_s (MSVCRT.@)
1787  */
1788 int CDECL _wsearchenv_s(const MSVCRT_wchar_t* file, const MSVCRT_wchar_t* env,
1789                         MSVCRT_wchar_t *buf, MSVCRT_size_t count)
1790 {
1791   MSVCRT_wchar_t*       envVal, *penv;
1792   MSVCRT_wchar_t        curPath[MAX_PATH];
1793
1794   if (!MSVCRT_CHECK_PMT(file != NULL) || !MSVCRT_CHECK_PMT(buf != NULL) ||
1795       !MSVCRT_CHECK_PMT(count > 0))
1796   {
1797       *MSVCRT__errno() = MSVCRT_EINVAL;
1798       return MSVCRT_EINVAL;
1799   }
1800   *buf = '\0';
1801
1802   /* Try CWD first */
1803   if (GetFileAttributesW( file ) != INVALID_FILE_ATTRIBUTES)
1804   {
1805     if (GetFullPathNameW( file, count, buf, NULL )) return 0;
1806     msvcrt_set_errno(GetLastError());
1807     return 0;
1808   }
1809
1810   /* Search given environment variable */
1811   envVal = MSVCRT__wgetenv(env);
1812   if (!envVal)
1813   {
1814     *MSVCRT__errno() = MSVCRT_ENOENT;
1815     return MSVCRT_ENOENT;
1816   }
1817
1818   penv = envVal;
1819   TRACE(":searching for %s in paths %s\n", debugstr_w(file), debugstr_w(envVal));
1820
1821   do
1822   {
1823     MSVCRT_wchar_t *end = penv;
1824
1825     while(*end && *end != ';') end++; /* Find end of next path */
1826     if (penv == end || !*penv)
1827     {
1828       *MSVCRT__errno() = MSVCRT_ENOENT;
1829       return MSVCRT_ENOENT;
1830     }
1831     memcpy(curPath, penv, (end - penv) * sizeof(MSVCRT_wchar_t));
1832     if (curPath[end - penv] != '/' && curPath[end - penv] != '\\')
1833     {
1834       curPath[end - penv] = '\\';
1835       curPath[end - penv + 1] = '\0';
1836     }
1837     else
1838       curPath[end - penv] = '\0';
1839
1840     strcatW(curPath, file);
1841     TRACE("Checking for file %s\n", debugstr_w(curPath));
1842     if (GetFileAttributesW( curPath ) != INVALID_FILE_ATTRIBUTES)
1843     {
1844       if (strlenW(curPath) + 1 > count)
1845       {
1846           MSVCRT_INVALID_PMT("buf[count] is too small");
1847           *MSVCRT__errno() = MSVCRT_ERANGE;
1848           return MSVCRT_ERANGE;
1849       }
1850       strcpyW(buf, curPath);
1851       return 0;
1852     }
1853     penv = *end ? end + 1 : end;
1854   } while(1);
1855 }