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