git.oblomov.eu Git - wine/blob - 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26
  27 #include <time.h>
  28 #include "winternl.h"
  29 #include "wine/unicode.h"
  30 #include "msvcrt.h"
  31 #include "msvcrt/errno.h"
  32
  33 #include "wine/unicode.h"
  34 #include "msvcrt/direct.h"
  35 #include "msvcrt/dos.h"
  36 #include "msvcrt/io.h"
  37 #include "msvcrt/stdlib.h"
  38 #include "msvcrt/string.h"
  39
  40 #include "wine/debug.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  43
  44 /* INTERNAL: Translate finddata_t to PWIN32_FIND_DATAA */
  45 static void msvcrt_fttofd(LPWIN32_FIND_DATAA fd, struct _finddata_t* ft)
  46 {
  47   DWORD dw;
  48
  49   if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
  50     ft->attrib = 0;
  51   else
  52     ft->attrib = fd->dwFileAttributes;
  53
  54   RtlTimeToSecondsSince1970( (LARGE_INTEGER *)&fd->ftCreationTime, &dw );
  55   ft->time_create = dw;
  56   RtlTimeToSecondsSince1970( (LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
  57   ft->time_access = dw;
  58   RtlTimeToSecondsSince1970( (LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
  59   ft->time_write = dw;
  60   ft->size = fd->nFileSizeLow;
  61   strcpy(ft->name, fd->cFileName);
  62 }
  63
  64 /* INTERNAL: Translate wfinddata_t to PWIN32_FIND_DATAA */
  65 static void msvcrt_wfttofd(LPWIN32_FIND_DATAW fd, struct _wfinddata_t* ft)
  66 {
  67   DWORD dw;
  68
  69   if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
  70     ft->attrib = 0;
  71   else
  72     ft->attrib = fd->dwFileAttributes;
  73
  74   RtlTimeToSecondsSince1970( (LARGE_INTEGER *)&fd->ftCreationTime, &dw );
  75   ft->time_create = dw;
  76   RtlTimeToSecondsSince1970( (LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
  77   ft->time_access = dw;
  78   RtlTimeToSecondsSince1970( (LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
  79   ft->time_write = dw;
  80   ft->size = fd->nFileSizeLow;
  81   strcpyW(ft->name, fd->cFileName);
  82 }
  83
  84 /*********************************************************************
  85  *              _chdir (MSVCRT.@)
  86  */
  87 int _chdir(const char * newdir)
  88 {
  89   if (!SetCurrentDirectoryA(newdir))
  90   {
  91     MSVCRT__set_errno(newdir?GetLastError():0);
  92     return -1;
  93   }
  94   return 0;
  95 }
  96
  97 /*********************************************************************
  98  *              _wchdir (MSVCRT.@)
  99  */
 100 int _wchdir(const MSVCRT_wchar_t * newdir)
 101 {
 102   if (!SetCurrentDirectoryW(newdir))
 103   {
 104     MSVCRT__set_errno(newdir?GetLastError():0);
 105     return -1;
 106   }
 107   return 0;
 108 }
 109
 110 /*********************************************************************
 111  *              _chdrive (MSVCRT.@)
 112  */
 113 int _chdrive(int newdrive)
 114 {
 115   char buffer[3] = "A:";
 116   buffer[0] += newdrive - 1;
 117   if (!SetCurrentDirectoryA( buffer ))
 118   {
 119     MSVCRT__set_errno(GetLastError());
 120     if (newdrive <= 0)
 121       *MSVCRT__errno() = MSVCRT_EACCES;
 122     return -1;
 123   }
 124   return 0;
 125 }
 126
 127 /*********************************************************************
 128  *              _findclose (MSVCRT.@)
 129  */
 130 int _findclose(long hand)
 131 {
 132   TRACE(":handle %ld\n",hand);
 133   if (!FindClose((HANDLE)hand))
 134   {
 135     MSVCRT__set_errno(GetLastError());
 136     return -1;
 137   }
 138   return 0;
 139 }
 140
 141 /*********************************************************************
 142  *              _findfirst (MSVCRT.@)
 143  */
 144 long _findfirst(const char * fspec, struct _finddata_t* ft)
 145 {
 146   WIN32_FIND_DATAA find_data;
 147   HANDLE hfind;
 148
 149   hfind  = FindFirstFileA(fspec, &find_data);
 150   if (hfind == INVALID_HANDLE_VALUE)
 151   {
 152     MSVCRT__set_errno(GetLastError());
 153     return -1;
 154   }
 155   msvcrt_fttofd(&find_data,ft);
 156   TRACE(":got handle %p\n",hfind);
 157   return (long)hfind;
 158 }
 159
 160 /*********************************************************************
 161  *              _wfindfirst (MSVCRT.@)
 162  */
 163 long _wfindfirst(const MSVCRT_wchar_t * fspec, struct _wfinddata_t* ft)
 164 {
 165   WIN32_FIND_DATAW find_data;
 166   HANDLE hfind;
 167
 168   hfind  = FindFirstFileW(fspec, &find_data);
 169   if (hfind == INVALID_HANDLE_VALUE)
 170   {
 171     MSVCRT__set_errno(GetLastError());
 172     return -1;
 173   }
 174   msvcrt_wfttofd(&find_data,ft);
 175   TRACE(":got handle %p\n",hfind);
 176   return (long)hfind;
 177 }
 178
 179 /*********************************************************************
 180  *              _findnext (MSVCRT.@)
 181  */
 182 int _findnext(long hand, struct _finddata_t * ft)
 183 {
 184   WIN32_FIND_DATAA find_data;
 185
 186   if (!FindNextFileA((HANDLE)hand, &find_data))
 187   {
 188     *MSVCRT__errno() = MSVCRT_ENOENT;
 189     return -1;
 190   }
 191
 192   msvcrt_fttofd(&find_data,ft);
 193   return 0;
 194 }
 195
 196 /*********************************************************************
 197  *              _wfindnext (MSVCRT.@)
 198  */
 199 int _wfindnext(long hand, struct _wfinddata_t * ft)
 200 {
 201   WIN32_FIND_DATAW find_data;
 202
 203   if (!FindNextFileW((HANDLE)hand, &find_data))
 204   {
 205     *MSVCRT__errno() = MSVCRT_ENOENT;
 206     return -1;
 207   }
 208
 209   msvcrt_wfttofd(&find_data,ft);
 210   return 0;
 211 }
 212
 213 /*********************************************************************
 214  *              _getcwd (MSVCRT.@)
 215  */
 216 char* _getcwd(char * buf, int size)
 217 {
 218   char dir[MAX_PATH];
 219   int dir_len = GetCurrentDirectoryA(MAX_PATH,dir);
 220
 221   if (dir_len < 1)
 222     return NULL; /* FIXME: Real return value untested */
 223
 224   if (!buf)
 225   {
 226     if (size < 0)
 227       return _strdup(dir);
 228     return msvcrt_strndup(dir,size);
 229   }
 230   if (dir_len >= size)
 231   {
 232     *MSVCRT__errno() = MSVCRT_ERANGE;
 233     return NULL; /* buf too small */
 234   }
 235   strcpy(buf,dir);
 236   return buf;
 237 }
 238
 239 /*********************************************************************
 240  *              _wgetcwd (MSVCRT.@)
 241  */
 242 MSVCRT_wchar_t* _wgetcwd(MSVCRT_wchar_t * buf, int size)
 243 {
 244   MSVCRT_wchar_t dir[MAX_PATH];
 245   int dir_len = GetCurrentDirectoryW(MAX_PATH,dir);
 246
 247   if (dir_len < 1)
 248     return NULL; /* FIXME: Real return value untested */
 249
 250   if (!buf)
 251   {
 252     if (size < 0)
 253       return _wcsdup(dir);
 254     return msvcrt_wstrndup(dir,size);
 255   }
 256   if (dir_len >= size)
 257   {
 258     *MSVCRT__errno() = MSVCRT_ERANGE;
 259     return NULL; /* buf too small */
 260   }
 261   strcpyW(buf,dir);
 262   return buf;
 263 }
 264
 265 /*********************************************************************
 266  *              _getdrive (MSVCRT.@)
 267  */
 268 int _getdrive(void)
 269 {
 270     char buffer[MAX_PATH];
 271     if (!GetCurrentDirectoryA( sizeof(buffer), buffer )) return 0;
 272     if (buffer[1] != ':') return 0;
 273     return toupper(buffer[0]) - 'A' + 1;
 274 }
 275
 276 /*********************************************************************
 277  *              _getdcwd (MSVCRT.@)
 278  */
 279 char* _getdcwd(int drive, char * buf, int size)
 280 {
 281   static char* dummy;
 282
 283   TRACE(":drive %d(%c), size %d\n",drive, drive + 'A' - 1, size);
 284
 285   if (!drive || drive == _getdrive())
 286     return _getcwd(buf,size); /* current */
 287   else
 288   {
 289     char dir[MAX_PATH];
 290     char drivespec[4] = {'A', ':', '\\', 0};
 291     int dir_len;
 292
 293     drivespec[0] += drive - 1;
 294     if (GetDriveTypeA(drivespec) < DRIVE_REMOVABLE)
 295     {
 296       *MSVCRT__errno() = MSVCRT_EACCES;
 297       return NULL;
 298     }
 299
 300     dir_len = GetFullPathNameA(drivespec,MAX_PATH,dir,&dummy);
 301     if (dir_len >= size || dir_len < 1)
 302     {
 303       *MSVCRT__errno() = MSVCRT_ERANGE;
 304       return NULL; /* buf too small */
 305     }
 306
 307     TRACE(":returning '%s'\n", dir);
 308     if (!buf)
 309       return _strdup(dir); /* allocate */
 310
 311     strcpy(buf,dir);
 312   }
 313   return buf;
 314 }
 315
 316 /*********************************************************************
 317  *              _wgetdcwd (MSVCRT.@)
 318  */
 319 MSVCRT_wchar_t* _wgetdcwd(int drive, MSVCRT_wchar_t * buf, int size)
 320 {
 321   static MSVCRT_wchar_t* dummy;
 322
 323   TRACE(":drive %d(%c), size %d\n",drive, drive + 'A' - 1, size);
 324
 325   if (!drive || drive == _getdrive())
 326     return _wgetcwd(buf,size); /* current */
 327   else
 328   {
 329     MSVCRT_wchar_t dir[MAX_PATH];
 330     MSVCRT_wchar_t drivespec[4] = {'A', ':', '\\', 0};
 331     int dir_len;
 332
 333     drivespec[0] += drive - 1;
 334     if (GetDriveTypeW(drivespec) < DRIVE_REMOVABLE)
 335     {
 336       *MSVCRT__errno() = MSVCRT_EACCES;
 337       return NULL;
 338     }
 339
 340     dir_len = GetFullPathNameW(drivespec,MAX_PATH,dir,&dummy);
 341     if (dir_len >= size || dir_len < 1)
 342     {
 343       *MSVCRT__errno() = MSVCRT_ERANGE;
 344       return NULL; /* buf too small */
 345     }
 346
 347     TRACE(":returning %s\n", debugstr_w(dir));
 348     if (!buf)
 349       return _wcsdup(dir); /* allocate */
 350     strcpyW(buf,dir);
 351   }
 352   return buf;
 353 }
 354
 355 /*********************************************************************
 356  *              _getdiskfree (MSVCRT.@)
 357  */
 358 unsigned int _getdiskfree(unsigned int disk, struct _diskfree_t* d)
 359 {
 360   char drivespec[4] = {'@', ':', '\\', 0};
 361   DWORD ret[4];
 362   unsigned int err;
 363
 364   if (disk > 26)
 365     return ERROR_INVALID_PARAMETER; /* MSVCRT doesn't set errno here */
 366
 367   drivespec[0] += disk; /* make a drive letter */
 368
 369   if (GetDiskFreeSpaceA(disk==0?NULL:drivespec,ret,ret+1,ret+2,ret+3))
 370   {
 371     d->sectors_per_cluster = (unsigned)ret[0];
 372     d->bytes_per_sector = (unsigned)ret[1];
 373     d->avail_clusters = (unsigned)ret[2];
 374     d->total_clusters = (unsigned)ret[3];
 375     return 0;
 376   }
 377   err = GetLastError();
 378   MSVCRT__set_errno(err);
 379   return err;
 380 }
 381
 382 /*********************************************************************
 383  *              _mkdir (MSVCRT.@)
 384  */
 385 int _mkdir(const char * newdir)
 386 {
 387   if (CreateDirectoryA(newdir,NULL))
 388     return 0;
 389   MSVCRT__set_errno(GetLastError());
 390   return -1;
 391 }
 392
 393 /*********************************************************************
 394  *              _wmkdir (MSVCRT.@)
 395  */
 396 int _wmkdir(const MSVCRT_wchar_t* newdir)
 397 {
 398   if (CreateDirectoryW(newdir,NULL))
 399     return 0;
 400   MSVCRT__set_errno(GetLastError());
 401   return -1;
 402 }
 403
 404 /*********************************************************************
 405  *              _rmdir (MSVCRT.@)
 406  */
 407 int _rmdir(const char * dir)
 408 {
 409   if (RemoveDirectoryA(dir))
 410     return 0;
 411   MSVCRT__set_errno(GetLastError());
 412   return -1;
 413 }
 414
 415 /*********************************************************************
 416  *              _wrmdir (MSVCRT.@)
 417  */
 418 int _wrmdir(const MSVCRT_wchar_t * dir)
 419 {
 420   if (RemoveDirectoryW(dir))
 421     return 0;
 422   MSVCRT__set_errno(GetLastError());
 423   return -1;
 424 }
 425
 426 /*********************************************************************
 427  *              _wsplitpath (MSVCRT.@)
 428  */
 429 void _wsplitpath(const MSVCRT_wchar_t *inpath, MSVCRT_wchar_t *drv, MSVCRT_wchar_t *dir,
 430                  MSVCRT_wchar_t *fname, MSVCRT_wchar_t *ext )
 431 {
 432   /* Modified PD code from 'snippets' collection. */
 433   MSVCRT_wchar_t ch, *ptr, *p;
 434   MSVCRT_wchar_t pathbuff[MAX_PATH],*path=pathbuff;
 435
 436   /* FIXME: Should be an strncpyW or something */
 437   strcpyW(pathbuff, inpath);
 438   TRACE(":splitting path %s\n",debugstr_w(path));
 439
 440   /* convert slashes to backslashes for searching */
 441   for (ptr = (MSVCRT_wchar_t*)path; *ptr; ++ptr)
 442     if (*ptr == '/')
 443       *ptr = '\\';
 444
 445   /* look for drive spec */
 446   if ((ptr = strchrW(path, ':')) != 0)
 447   {
 448     ++ptr;
 449     if (drv)
 450     {
 451       strncpyW(drv, path, ptr - path);
 452       drv[ptr - path] = 0;
 453     }
 454     path = ptr;
 455   }
 456   else if (drv)
 457     *drv = 0;
 458
 459   /* find rightmost backslash or leftmost colon */
 460   if ((ptr = strrchrW(path, '\\')) == NULL)
 461     ptr = (strchrW(path, ':'));
 462
 463   if (!ptr)
 464   {
 465     ptr = (MSVCRT_wchar_t *)path; /* no path */
 466     if (dir)
 467       *dir = 0;
 468   }
 469   else
 470   {
 471     ++ptr; /* skip the delimiter */
 472     if (dir)
 473     {
 474       ch = *ptr;
 475       *ptr = 0;
 476       strcpyW(dir, path);
 477       *ptr = ch;
 478     }
 479   }
 480
 481   if ((p = strrchrW(ptr, '.')) == NULL)
 482   {
 483     if (fname)
 484       strcpyW(fname, ptr);
 485     if (ext)
 486       *ext = 0;
 487   }
 488   else
 489   {
 490     *p = 0;
 491     if (fname)
 492       strcpyW(fname, ptr);
 493     *p = '.';
 494     if (ext)
 495       strcpyW(ext, p);
 496   }
 497
 498   /* Fix pathological case - Win returns ':' as part of the
 499    * directory when no drive letter is given.
 500    */
 501   if (drv && drv[0] == ':')
 502   {
 503     *drv = 0;
 504     if (dir)
 505     {
 506       pathbuff[0] = ':';
 507       pathbuff[1] = 0;
 508       strcatW(pathbuff,dir);
 509       strcpyW(dir, pathbuff);
 510     }
 511   }
 512 }
 513
 514 /* INTERNAL: Helper for _fullpath. Modified PD code from 'snippets'. */
 515 static void wmsvcrt_fln_fix(MSVCRT_wchar_t *path)
 516 {
 517   int dir_flag = 0, root_flag = 0;
 518   MSVCRT_wchar_t *r, *p, *q, *s;
 519   MSVCRT_wchar_t szbsdot[] = { '\\', '.', 0 };
 520
 521   /* Skip drive */
 522   if (NULL == (r = strrchrW(path, ':')))
 523     r = path;
 524   else
 525     ++r;
 526
 527   /* Ignore leading slashes */
 528   while ('\\' == *r)
 529     if ('\\' == r[1])
 530       strcpyW(r, &r[1]);
 531     else
 532     {
 533       root_flag = 1;
 534       ++r;
 535     }
 536
 537   p = r; /* Change "\\" to "\" */
 538   while (NULL != (p = strchrW(p, '\\')))
 539     if ('\\' ==  p[1])
 540       strcpyW(p, &p[1]);
 541     else
 542       ++p;
 543
 544   while ('.' == *r) /* Scrunch leading ".\" */
 545   {
 546     if ('.' == r[1])
 547     {
 548       /* Ignore leading ".." */
 549       for (p = (r += 2); *p && (*p != '\\'); ++p)
 550         ;
 551     }
 552     else
 553     {
 554       for (p = r + 1 ;*p && (*p != '\\'); ++p)
 555         ;
 556     }
 557     strcpyW(r, p + ((*p) ? 1 : 0));
 558   }
 559
 560   while ('\\' == path[strlenW(path)-1])   /* Strip last '\\' */
 561   {
 562     dir_flag = 1;
 563     path[strlenW(path)-1] = '\0';
 564   }
 565
 566   s = r;
 567
 568   /* Look for "\." in path */
 569
 570   while (NULL != (p = strstrW(s, szbsdot)))
 571   {
 572     if ('.' == p[2])
 573     {
 574       /* Execute this section if ".." found */
 575       q = p - 1;
 576       while (q > r)           /* Backup one level           */
 577       {
 578         if (*q == '\\')
 579           break;
 580         --q;
 581       }
 582       if (q > r)
 583       {
 584         strcpyW(q, p + 3);
 585         s = q;
 586       }
 587       else if ('.' != *q)
 588       {
 589         strcpyW(q + ((*q == '\\') ? 1 : 0),
 590                p + 3 + ((*(p + 3)) ? 1 : 0));
 591         s = q;
 592       }
 593       else  s = ++p;
 594     }
 595     else
 596     {
 597       /* Execute this section if "." found */
 598       q = p + 2;
 599       for ( ;*q && (*q != '\\'); ++q)
 600         ;
 601       strcpyW (p, q);
 602     }
 603   }
 604
 605   if (root_flag)  /* Embedded ".." could have bubbled up to root  */
 606   {
 607     for (p = r; *p && ('.' == *p || '\\' == *p); ++p)
 608       ;
 609     if (r != p)
 610       strcpyW(r, p);
 611   }
 612
 613   if (dir_flag)
 614   {
 615     MSVCRT_wchar_t szbs[] = { '\\', 0 };
 616
 617     strcatW(path, szbs);
 618   }
 619 }
 620
 621 /*********************************************************************
 622  *              _wfullpath (MSVCRT.@)
 623  */
 624 MSVCRT_wchar_t *_wfullpath(MSVCRT_wchar_t * absPath, const MSVCRT_wchar_t* relPath, unsigned int size)
 625 {
 626   MSVCRT_wchar_t drive[5],dir[MAX_PATH],file[MAX_PATH],ext[MAX_PATH];
 627   MSVCRT_wchar_t res[MAX_PATH];
 628   size_t len;
 629   MSVCRT_wchar_t szbs[] = { '\\', 0 };
 630
 631
 632   res[0] = '\0';
 633
 634   if (!relPath || !*relPath)
 635     return _wgetcwd(absPath, size);
 636
 637   if (size < 4)
 638   {
 639     *MSVCRT__errno() = MSVCRT_ERANGE;
 640     return NULL;
 641   }
 642
 643   TRACE(":resolving relative path '%s'\n",debugstr_w(relPath));
 644
 645   _wsplitpath(relPath, drive, dir, file, ext);
 646
 647   /* Get Directory and drive into 'res' */
 648   if (!dir[0] || (dir[0] != '/' && dir[0] != '\\'))
 649   {
 650     /* Relative or no directory given */
 651     _wgetdcwd(drive[0] ? toupper(drive[0]) - 'A' + 1 :  0, res, MAX_PATH);
 652     strcatW(res,szbs);
 653     if (dir[0])
 654       strcatW(res,dir);
 655     if (drive[0])
 656       res[0] = drive[0]; /* If given a drive, preserve the letter case */
 657   }
 658   else
 659   {
 660     strcpyW(res,drive);
 661     strcatW(res,dir);
 662   }
 663
 664   strcatW(res,szbs);
 665   strcatW(res, file);
 666   strcatW(res, ext);
 667   wmsvcrt_fln_fix(res);
 668
 669   len = strlenW(res);
 670   if (len >= MAX_PATH || len >= (size_t)size)
 671     return NULL; /* FIXME: errno? */
 672
 673   if (!absPath)
 674     return _wcsdup(res);
 675   strcpyW(absPath,res);
 676   return absPath;
 677 }
 678
 679 /* INTERNAL: Helper for _fullpath. Modified PD code from 'snippets'. */
 680 static void msvcrt_fln_fix(char *path)
 681 {
 682   int dir_flag = 0, root_flag = 0;
 683   char *r, *p, *q, *s;
 684
 685   /* Skip drive */
 686   if (NULL == (r = strrchr(path, ':')))
 687     r = path;
 688   else
 689     ++r;
 690
 691   /* Ignore leading slashes */
 692   while ('\\' == *r)
 693     if ('\\' == r[1])
 694       strcpy(r, &r[1]);
 695     else
 696     {
 697       root_flag = 1;
 698       ++r;
 699     }
 700
 701   p = r; /* Change "\\" to "\" */
 702   while (NULL != (p = strchr(p, '\\')))
 703     if ('\\' ==  p[1])
 704       strcpy(p, &p[1]);
 705     else
 706       ++p;
 707
 708   while ('.' == *r) /* Scrunch leading ".\" */
 709   {
 710     if ('.' == r[1])
 711     {
 712       /* Ignore leading ".." */
 713       for (p = (r += 2); *p && (*p != '\\'); ++p)
 714         ;
 715     }
 716     else
 717     {
 718       for (p = r + 1 ;*p && (*p != '\\'); ++p)
 719         ;
 720     }
 721     strcpy(r, p + ((*p) ? 1 : 0));
 722   }
 723
 724   while ('\\' == path[strlen(path)-1])   /* Strip last '\\' */
 725   {
 726     dir_flag = 1;
 727     path[strlen(path)-1] = '\0';
 728   }
 729
 730   s = r;
 731
 732   /* Look for "\." in path */
 733
 734   while (NULL != (p = strstr(s, "\\.")))
 735   {
 736     if ('.' == p[2])
 737     {
 738       /* Execute this section if ".." found */
 739       q = p - 1;
 740       while (q > r)           /* Backup one level           */
 741       {
 742         if (*q == '\\')
 743           break;
 744         --q;
 745       }
 746       if (q > r)
 747       {
 748         strcpy(q, p + 3);
 749         s = q;
 750       }
 751       else if ('.' != *q)
 752       {
 753         strcpy(q + ((*q == '\\') ? 1 : 0),
 754                p + 3 + ((*(p + 3)) ? 1 : 0));
 755         s = q;
 756       }
 757       else  s = ++p;
 758     }
 759     else
 760     {
 761       /* Execute this section if "." found */
 762       q = p + 2;
 763       for ( ;*q && (*q != '\\'); ++q)
 764         ;
 765       strcpy (p, q);
 766     }
 767   }
 768
 769   if (root_flag)  /* Embedded ".." could have bubbled up to root  */
 770   {
 771     for (p = r; *p && ('.' == *p || '\\' == *p); ++p)
 772       ;
 773     if (r != p)
 774       strcpy(r, p);
 775   }
 776
 777   if (dir_flag)
 778     strcat(path, "\\");
 779 }
 780
 781 /*********************************************************************
 782  *              _fullpath (MSVCRT.@)
 783  */
 784 char *_fullpath(char * absPath, const char* relPath, unsigned int size)
 785 {
 786   char drive[5],dir[MAX_PATH],file[MAX_PATH],ext[MAX_PATH];
 787   char res[MAX_PATH];
 788   size_t len;
 789
 790   res[0] = '\0';
 791
 792   if (!relPath || !*relPath)
 793     return _getcwd(absPath, size);
 794
 795   if (size < 4)
 796   {
 797     *MSVCRT__errno() = MSVCRT_ERANGE;
 798     return NULL;
 799   }
 800
 801   TRACE(":resolving relative path '%s'\n",relPath);
 802
 803   _splitpath(relPath, drive, dir, file, ext);
 804
 805   /* Get Directory and drive into 'res' */
 806   if (!dir[0] || (dir[0] != '/' && dir[0] != '\\'))
 807   {
 808     /* Relative or no directory given */
 809     _getdcwd(drive[0] ? toupper(drive[0]) - 'A' + 1 :  0, res, MAX_PATH);
 810     strcat(res,"\\");
 811     if (dir[0])
 812       strcat(res,dir);
 813     if (drive[0])
 814       res[0] = drive[0]; /* If given a drive, preserve the letter case */
 815   }
 816   else
 817   {
 818     strcpy(res,drive);
 819     strcat(res,dir);
 820   }
 821
 822   strcat(res,"\\");
 823   strcat(res, file);
 824   strcat(res, ext);
 825   msvcrt_fln_fix(res);
 826
 827   len = strlen(res);
 828   if (len >= MAX_PATH || len >= (size_t)size)
 829     return NULL; /* FIXME: errno? */
 830
 831   if (!absPath)
 832     return _strdup(res);
 833   strcpy(absPath,res);
 834   return absPath;
 835 }
 836
 837 /*********************************************************************
 838  *              _makepath (MSVCRT.@)
 839  */
 840 VOID _makepath(char * path, const char * drive,
 841                               const char *directory, const char * filename,
 842                               const char * extension )
 843 {
 844     char ch;
 845     char tmpPath[MAX_PATH];
 846     TRACE("got %s %s %s %s\n", debugstr_a(drive), debugstr_a(directory),
 847           debugstr_a(filename), debugstr_a(extension) );
 848
 849     if ( !path )
 850         return;
 851
 852     tmpPath[0] = '\0';
 853     if (drive && drive[0])
 854     {
 855         tmpPath[0] = drive[0];
 856         tmpPath[1] = ':';
 857         tmpPath[2] = 0;
 858     }
 859     if (directory && directory[0])
 860     {
 861         strcat(tmpPath, directory);
 862         ch = tmpPath[strlen(tmpPath)-1];
 863         if (ch != '/' && ch != '\\')
 864             strcat(tmpPath,"\\");
 865     }
 866     if (filename && filename[0])
 867     {
 868         strcat(tmpPath, filename);
 869         if (extension && extension[0])
 870         {
 871             if ( extension[0] != '.' )
 872                 strcat(tmpPath,".");
 873             strcat(tmpPath,extension);
 874         }
 875     }
 876
 877     strcpy( path, tmpPath );
 878
 879     TRACE("returning %s\n",path);
 880 }
 881
 882 /*********************************************************************
 883  *              _wmakepath (MSVCRT.@)
 884  */
 885 VOID _wmakepath(MSVCRT_wchar_t *path, const MSVCRT_wchar_t *drive, const MSVCRT_wchar_t *directory,
 886                 const MSVCRT_wchar_t *filename, const MSVCRT_wchar_t *extension)
 887 {
 888     MSVCRT_wchar_t ch;
 889     TRACE("%s %s %s %s\n", debugstr_w(drive), debugstr_w(directory),
 890           debugstr_w(filename), debugstr_w(extension));
 891
 892     if ( !path )
 893         return;
 894
 895     path[0] = 0;
 896     if (drive && drive[0])
 897     {
 898         path[0] = drive[0];
 899         path[1] = ':';
 900         path[2] = 0;
 901     }
 902     if (directory && directory[0])
 903     {
 904         strcatW(path, directory);
 905         ch = path[strlenW(path) - 1];
 906         if (ch != '/' && ch != '\\')
 907         {
 908             static const MSVCRT_wchar_t backslashW[] = {'\\',0};
 909             strcatW(path, backslashW);
 910         }
 911     }
 912     if (filename && filename[0])
 913     {
 914         strcatW(path, filename);
 915         if (extension && extension[0])
 916         {
 917             if ( extension[0] != '.' )
 918             {
 919                 static const MSVCRT_wchar_t dotW[] = {'.',0};
 920                 strcatW(path, dotW);
 921             }
 922             strcatW(path, extension);
 923         }
 924     }
 925
 926     TRACE("returning %s\n", debugstr_w(path));
 927 }
 928
 929 /*********************************************************************
 930  *              _searchenv (MSVCRT.@)
 931  */
 932 void _searchenv(const char* file, const char* env, char *buf)
 933 {
 934   char*envVal, *penv;
 935   char curPath[MAX_PATH];
 936
 937   *buf = '\0';
 938
 939   /* Try CWD first */
 940   if (GetFileAttributesA( file ) != 0xFFFFFFFF)
 941   {
 942     GetFullPathNameA( file, MAX_PATH, buf, NULL );
 943     /* Sigh. This error is *always* set, regardless of success */
 944     MSVCRT__set_errno(ERROR_FILE_NOT_FOUND);
 945     return;
 946   }
 947
 948   /* Search given environment variable */
 949   envVal = MSVCRT_getenv(env);
 950   if (!envVal)
 951   {
 952     MSVCRT__set_errno(ERROR_FILE_NOT_FOUND);
 953     return;
 954   }
 955
 956   penv = envVal;
 957   TRACE(":searching for %s in paths %s\n", file, envVal);
 958
 959   do
 960   {
 961     char *end = penv;
 962
 963     while(*end && *end != ';') end++; /* Find end of next path */
 964     if (penv == end || !*penv)
 965     {
 966       MSVCRT__set_errno(ERROR_FILE_NOT_FOUND);
 967       return;
 968     }
 969     strncpy(curPath, penv, end - penv);
 970     if (curPath[end - penv] != '/' || curPath[end - penv] != '\\')
 971     {
 972       curPath[end - penv] = '\\';
 973       curPath[end - penv + 1] = '\0';
 974     }
 975     else
 976       curPath[end - penv] = '\0';
 977
 978     strcat(curPath, file);
 979     TRACE("Checking for file %s\n", curPath);
 980     if (GetFileAttributesA( curPath ) != 0xFFFFFFFF)
 981     {
 982       strcpy(buf, curPath);
 983       MSVCRT__set_errno(ERROR_FILE_NOT_FOUND);
 984       return; /* Found */
 985     }
 986     penv = *end ? end + 1 : end;
 987   } while(1);
 988 }