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 }
1856
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.