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