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