files/dos_fs.c

   1 /*
   2  * DOS file system functions
   3  *
   4  * Copyright 1993 Erik Bos
   5  * Copyright 1996 Alexandre Julliard
   6  */
   7
   8 #include "config.h"
   9 #include <sys/types.h>
  10 #include <ctype.h>
  11 #include <dirent.h>
  12 #include <errno.h>
  13 #include <sys/errno.h>
  14 #include <fcntl.h>
  15 #include <string.h>
  16 #include <stdlib.h>
  17 #include <sys/stat.h>
  18 #include <sys/ioctl.h>
  19 #include <time.h>
  20 #include <unistd.h>
  21
  22 #include "windows.h"
  23 #include "winerror.h"
  24 #include "drive.h"
  25 #include "file.h"
  26 #include "heap.h"
  27 #include "msdos.h"
  28 #include "syslevel.h"
  29 #include "debug.h"
  30
  31 /* Define the VFAT ioctl to get both short and long file names */
  32 /* FIXME: is it possible to get this to work on other systems? */
  33 #ifdef linux
  34 #define VFAT_IOCTL_READDIR_BOTH  _IOR('r', 1, long)
  35 /* We want the real kernel dirent structure, not the libc one */
  36 typedef struct
  37 {
  38     long d_ino;
  39     long d_off;
  40     unsigned short d_reclen;
  41     char d_name[256];
  42 } KERNEL_DIRENT;
  43
  44 #else   /* linux */
  45 #undef VFAT_IOCTL_READDIR_BOTH  /* just in case... */
  46 #endif  /* linux */
  47
  48 /* Chars we don't want to see in DOS file names */
  49 #define INVALID_DOS_CHARS  "*?<>|\"+=,;[] \345"
  50
  51 static const DOS_DEVICE DOSFS_Devices[] =
  52 /* name, device flags (see Int 21/AX=0x4400) */
  53 {
  54     { "CON",            0xc0d3 },
  55     { "PRN",            0xa0c0 },
  56     { "NUL",            0x80c4 },
  57     { "AUX",            0x80c0 },
  58     { "LPT1",           0xa0c0 },
  59     { "LPT2",           0xa0c0 },
  60     { "LPT3",           0xa0c0 },
  61     { "LPT4",           0xc0d3 },
  62     { "COM1",           0x80c0 },
  63     { "COM2",           0x80c0 },
  64     { "COM3",           0x80c0 },
  65     { "COM4",           0x80c0 },
  66     { "SCSIMGR$",       0xc0c0 },
  67     { "HPSCAN",         0xc0c0 }
  68 };
  69
  70 #define GET_DRIVE(path) \
  71     (((path)[1] == ':') ? toupper((path)[0]) - 'A' : DOSFS_CurDrive)
  72
  73     /* DOS extended error status */
  74 WORD DOS_ExtendedError;
  75 BYTE DOS_ErrorClass;
  76 BYTE DOS_ErrorAction;
  77 BYTE DOS_ErrorLocus;
  78
  79 /* Directory info for DOSFS_ReadDir */
  80 typedef struct
  81 {
  82     DIR           *dir;
  83 #ifdef VFAT_IOCTL_READDIR_BOTH
  84     int            fd;
  85     char           short_name[12];
  86     KERNEL_DIRENT  dirent[2];
  87 #endif
  88 } DOS_DIR;
  89
  90 /* Info structure for FindFirstFile handle */
  91 typedef struct
  92 {
  93     LPSTR path;
  94     LPSTR long_mask;
  95     LPSTR short_mask;
  96     BYTE  attr;
  97     int   drive;
  98     int   cur_pos;
  99     DOS_DIR *dir;
 100 } FIND_FIRST_INFO;
 101
 102
 103
 104 /***********************************************************************
 105  *           DOSFS_ValidDOSName
 106  *
 107  * Return 1 if Unix file 'name' is also a valid MS-DOS name
 108  * (i.e. contains only valid DOS chars, lower-case only, fits in 8.3 format).
 109  * File name can be terminated by '\0', '\\' or '/'.
 110  */
 111 static int DOSFS_ValidDOSName( const char *name, int ignore_case )
 112 {
 113     static const char invalid_chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" INVALID_DOS_CHARS;
 114     const char *p = name;
 115     const char *invalid = ignore_case ? (invalid_chars + 26) : invalid_chars;
 116     int len = 0;
 117
 118     if (*p == '.')
 119     {
 120         /* Check for "." and ".." */
 121         p++;
 122         if (*p == '.') p++;
 123         /* All other names beginning with '.' are invalid */
 124         return (IS_END_OF_NAME(*p));
 125     }
 126     while (!IS_END_OF_NAME(*p))
 127     {
 128         if (strchr( invalid, *p )) return 0;  /* Invalid char */
 129         if (*p == '.') break;  /* Start of the extension */
 130         if (++len > 8) return 0;  /* Name too long */
 131         p++;
 132     }
 133     if (*p != '.') return 1;  /* End of name */
 134     p++;
 135     if (IS_END_OF_NAME(*p)) return 0;  /* Empty extension not allowed */
 136     len = 0;
 137     while (!IS_END_OF_NAME(*p))
 138     {
 139         if (strchr( invalid, *p )) return 0;  /* Invalid char */
 140         if (*p == '.') return 0;  /* Second extension not allowed */
 141         if (++len > 3) return 0;  /* Extension too long */
 142         p++;
 143     }
 144     return 1;
 145 }
 146
 147
 148 /***********************************************************************
 149  *           DOSFS_ToDosFCBFormat
 150  *
 151  * Convert a file name to DOS FCB format (8+3 chars, padded with blanks),
 152  * expanding wild cards and converting to upper-case in the process.
 153  * File name can be terminated by '\0', '\\' or '/'.
 154  * Return FALSE if the name is not a valid DOS name.
 155  * 'buffer' must be at least 12 characters long.
 156  */
 157 BOOL32 DOSFS_ToDosFCBFormat( LPCSTR name, LPSTR buffer )
 158 {
 159     static const char invalid_chars[] = INVALID_DOS_CHARS;
 160     const char *p = name;
 161     int i;
 162
 163     /* Check for "." and ".." */
 164     if (*p == '.')
 165     {
 166         p++;
 167         strcpy( buffer, ".          " );
 168         if (*p == '.')
 169         {
 170             buffer[1] = '.';
 171             p++;
 172         }
 173         return (!*p || (*p == '/') || (*p == '\\'));
 174     }
 175
 176     for (i = 0; i < 8; i++)
 177     {
 178         switch(*p)
 179         {
 180         case '\0':
 181         case '\\':
 182         case '/':
 183         case '.':
 184             buffer[i] = ' ';
 185             break;
 186         case '?':
 187             p++;
 188             /* fall through */
 189         case '*':
 190             buffer[i] = '?';
 191             break;
 192         default:
 193             if (strchr( invalid_chars, *p )) return FALSE;
 194             buffer[i] = toupper(*p);
 195             p++;
 196             break;
 197         }
 198     }
 199
 200     if (*p == '*')
 201     {
 202         /* Skip all chars after wildcard up to first dot */
 203         while (*p && (*p != '/') && (*p != '\\') && (*p != '.')) p++;
 204     }
 205     else
 206     {
 207         /* Check if name too long */
 208         if (*p && (*p != '/') && (*p != '\\') && (*p != '.')) return FALSE;
 209     }
 210     if (*p == '.') p++;  /* Skip dot */
 211
 212     for (i = 8; i < 11; i++)
 213     {
 214         switch(*p)
 215         {
 216         case '\0':
 217         case '\\':
 218         case '/':
 219             buffer[i] = ' ';
 220             break;
 221         case '.':
 222             return FALSE;  /* Second extension not allowed */
 223         case '?':
 224             p++;
 225             /* fall through */
 226         case '*':
 227             buffer[i] = '?';
 228             break;
 229         default:
 230             if (strchr( invalid_chars, *p )) return FALSE;
 231             buffer[i] = toupper(*p);
 232             p++;
 233             break;
 234         }
 235     }
 236     buffer[11] = '\0';
 237     return TRUE;
 238 }
 239
 240
 241 /***********************************************************************
 242  *           DOSFS_ToDosDTAFormat
 243  *
 244  * Convert a file name from FCB to DTA format (name.ext, null-terminated)
 245  * converting to upper-case in the process.
 246  * File name can be terminated by '\0', '\\' or '/'.
 247  * 'buffer' must be at least 13 characters long.
 248  */
 249 static void DOSFS_ToDosDTAFormat( LPCSTR name, LPSTR buffer )
 250 {
 251     char *p;
 252
 253     memcpy( buffer, name, 8 );
 254     for (p = buffer + 8; (p > buffer) && (p[-1] == ' '); p--);
 255     *p++ = '.';
 256     memcpy( p, name + 8, 3 );
 257     for (p += 3; p[-1] == ' '; p--);
 258     if (p[-1] == '.') p--;
 259     *p = '\0';
 260 }
 261
 262
 263 /***********************************************************************
 264  *           DOSFS_MatchShort
 265  *
 266  * Check a DOS file name against a mask (both in FCB format).
 267  */
 268 static int DOSFS_MatchShort( const char *mask, const char *name )
 269 {
 270     int i;
 271     for (i = 11; i > 0; i--, mask++, name++)
 272         if ((*mask != '?') && (*mask != *name)) return 0;
 273     return 1;
 274 }
 275
 276
 277 /***********************************************************************
 278  *           DOSFS_MatchLong
 279  *
 280  * Check a long file name against a mask.
 281  */
 282 static int DOSFS_MatchLong( const char *mask, const char *name,
 283                             int case_sensitive )
 284 {
 285     if (!strcmp( mask, "*.*" )) return 1;
 286     while (*name && *mask)
 287     {
 288         if (*mask == '*')
 289         {
 290             mask++;
 291             while (*mask == '*') mask++;  /* Skip consecutive '*' */
 292             if (!*mask) return 1;
 293             if (case_sensitive) while (*name && (*name != *mask)) name++;
 294             else while (*name && (toupper(*name) != toupper(*mask))) name++;
 295             if (!*name) return 0;
 296         }
 297         else if (*mask != '?')
 298         {
 299             if (case_sensitive)
 300             {
 301                 if (*mask != *name) return 0;
 302             }
 303             else if (toupper(*mask) != toupper(*name)) return 0;
 304         }
 305         mask++;
 306         name++;
 307     }
 308     return (!*name && !*mask);
 309 }
 310
 311
 312 /***********************************************************************
 313  *           DOSFS_OpenDir
 314  */
 315 static DOS_DIR *DOSFS_OpenDir( LPCSTR path )
 316 {
 317     DOS_DIR *dir = HeapAlloc( SystemHeap, 0, sizeof(*dir) );
 318     if (!dir)
 319     {
 320         DOS_ERROR( ER_OutOfMemory, EC_OutOfResource, SA_Abort, EL_Memory );
 321         return NULL;
 322     }
 323
 324     /* Treat empty path as root directory. This simplifies path split into
 325        directory and mask in several other places */
 326     if (!*path) path = "/";
 327
 328 #ifdef VFAT_IOCTL_READDIR_BOTH
 329
 330     /* Check if the VFAT ioctl is supported on this directory */
 331
 332     if ((dir->fd = open( path, O_RDONLY )) != -1)
 333     {
 334         if (ioctl( dir->fd, VFAT_IOCTL_READDIR_BOTH, (long)dir->dirent ) == -1)
 335         {
 336             close( dir->fd );
 337             dir->fd = -1;
 338         }
 339         else
 340         {
 341             /* Set the file pointer back at the start of the directory */
 342             lseek( dir->fd, 0, SEEK_SET );
 343             dir->dir = NULL;
 344             return dir;
 345         }
 346     }
 347 #endif  /* VFAT_IOCTL_READDIR_BOTH */
 348
 349     /* Now use the standard opendir/readdir interface */
 350
 351     if (!(dir->dir = opendir( path )))
 352     {
 353         HeapFree( SystemHeap, 0, dir );
 354         return NULL;
 355     }
 356     return dir;
 357 }
 358
 359
 360 /***********************************************************************
 361  *           DOSFS_CloseDir
 362  */
 363 static void DOSFS_CloseDir( DOS_DIR *dir )
 364 {
 365 #ifdef VFAT_IOCTL_READDIR_BOTH
 366     if (dir->fd != -1) close( dir->fd );
 367 #endif  /* VFAT_IOCTL_READDIR_BOTH */
 368     if (dir->dir) closedir( dir->dir );
 369     HeapFree( SystemHeap, 0, dir );
 370 }
 371
 372
 373 /***********************************************************************
 374  *           DOSFS_ReadDir
 375  */
 376 static BOOL32 DOSFS_ReadDir( DOS_DIR *dir, LPCSTR *long_name,
 377                              LPCSTR *short_name )
 378 {
 379     struct dirent *dirent;
 380
 381 #ifdef VFAT_IOCTL_READDIR_BOTH
 382     if (dir->fd != -1)
 383     {
 384         if (ioctl( dir->fd, VFAT_IOCTL_READDIR_BOTH, (long)dir->dirent ) != -1) {
 385             if (!dir->dirent[0].d_reclen) return FALSE;
 386             if (!DOSFS_ToDosFCBFormat( dir->dirent[0].d_name, dir->short_name ))
 387                 dir->short_name[0] = '\0';
 388             *short_name = dir->short_name;
 389             if (dir->dirent[1].d_name[0]) *long_name = dir->dirent[1].d_name;
 390             else *long_name = dir->dirent[0].d_name;
 391             return TRUE;
 392         }
 393     }
 394 #endif  /* VFAT_IOCTL_READDIR_BOTH */
 395
 396     if (!(dirent = readdir( dir->dir ))) return FALSE;
 397     *long_name  = dirent->d_name;
 398     *short_name = NULL;
 399     return TRUE;
 400 }
 401
 402
 403 /***********************************************************************
 404  *           DOSFS_Hash
 405  *
 406  * Transform a Unix file name into a hashed DOS name. If the name is a valid
 407  * DOS name, it is converted to upper-case; otherwise it is replaced by a
 408  * hashed version that fits in 8.3 format.
 409  * File name can be terminated by '\0', '\\' or '/'.
 410  * 'buffer' must be at least 13 characters long.
 411  */
 412 static void DOSFS_Hash( LPCSTR name, LPSTR buffer, BOOL32 dir_format,
 413                         BOOL32 ignore_case )
 414 {
 415     static const char invalid_chars[] = INVALID_DOS_CHARS "~.";
 416     static const char hash_chars[32] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ012345";
 417
 418     const char *p, *ext;
 419     char *dst;
 420     unsigned short hash;
 421     int i;
 422
 423     if (dir_format) strcpy( buffer, "           " );
 424
 425     if (DOSFS_ValidDOSName( name, ignore_case ))
 426     {
 427         /* Check for '.' and '..' */
 428         if (*name == '.')
 429         {
 430             buffer[0] = '.';
 431             if (!dir_format) buffer[1] = buffer[2] = '\0';
 432             if (name[1] == '.') buffer[1] = '.';
 433             return;
 434         }
 435
 436         /* Simply copy the name, converting to uppercase */
 437
 438         for (dst = buffer; !IS_END_OF_NAME(*name) && (*name != '.'); name++)
 439             *dst++ = toupper(*name);
 440         if (*name == '.')
 441         {
 442             if (dir_format) dst = buffer + 8;
 443             else *dst++ = '.';
 444             for (name++; !IS_END_OF_NAME(*name); name++)
 445                 *dst++ = toupper(*name);
 446         }
 447         if (!dir_format) *dst = '\0';
 448         return;
 449     }
 450
 451     /* Compute the hash code of the file name */
 452     /* If you know something about hash functions, feel free to */
 453     /* insert a better algorithm here... */
 454     if (ignore_case)
 455     {
 456         for (p = name, hash = 0xbeef; !IS_END_OF_NAME(p[1]); p++)
 457             hash = (hash<<3) ^ (hash>>5) ^ tolower(*p) ^ (tolower(p[1]) << 8);
 458         hash = (hash<<3) ^ (hash>>5) ^ tolower(*p); /* Last character*/
 459     }
 460     else
 461     {
 462         for (p = name, hash = 0xbeef; !IS_END_OF_NAME(p[1]); p++)
 463             hash = (hash << 3) ^ (hash >> 5) ^ *p ^ (p[1] << 8);
 464         hash = (hash << 3) ^ (hash >> 5) ^ *p;  /* Last character */
 465     }
 466
 467     /* Find last dot for start of the extension */
 468     for (p = name+1, ext = NULL; !IS_END_OF_NAME(*p); p++)
 469         if (*p == '.') ext = p;
 470     if (ext && IS_END_OF_NAME(ext[1]))
 471         ext = NULL;  /* Empty extension ignored */
 472
 473     /* Copy first 4 chars, replacing invalid chars with '_' */
 474     for (i = 4, p = name, dst = buffer; i > 0; i--, p++)
 475     {
 476         if (IS_END_OF_NAME(*p) || (p == ext)) break;
 477         *dst++ = strchr( invalid_chars, *p ) ? '_' : toupper(*p);
 478     }
 479     /* Pad to 5 chars with '~' */
 480     while (i-- >= 0) *dst++ = '~';
 481
 482     /* Insert hash code converted to 3 ASCII chars */
 483     *dst++ = hash_chars[(hash >> 10) & 0x1f];
 484     *dst++ = hash_chars[(hash >> 5) & 0x1f];
 485     *dst++ = hash_chars[hash & 0x1f];
 486
 487     /* Copy the first 3 chars of the extension (if any) */
 488     if (ext)
 489     {
 490         if (!dir_format) *dst++ = '.';
 491         for (i = 3, ext++; (i > 0) && !IS_END_OF_NAME(*ext); i--, ext++)
 492             *dst++ = strchr( invalid_chars, *ext ) ? '_' : toupper(*ext);
 493     }
 494     if (!dir_format) *dst = '\0';
 495 }
 496
 497
 498 /***********************************************************************
 499  *           DOSFS_FindUnixName
 500  *
 501  * Find the Unix file name in a given directory that corresponds to
 502  * a file name (either in Unix or DOS format).
 503  * File name can be terminated by '\0', '\\' or '/'.
 504  * Return TRUE if OK, FALSE if no file name matches.
 505  *
 506  * 'long_buf' must be at least 'long_len' characters long. If the long name
 507  * turns out to be larger than that, the function returns FALSE.
 508  * 'short_buf' must be at least 13 characters long.
 509  */
 510 BOOL32 DOSFS_FindUnixName( LPCSTR path, LPCSTR name, LPSTR long_buf,
 511                            INT32 long_len, LPSTR short_buf, BOOL32 ignore_case)
 512 {
 513     DOS_DIR *dir;
 514     LPCSTR long_name, short_name;
 515     char dos_name[12], tmp_buf[13];
 516     BOOL32 ret;
 517
 518     const char *p = strchr( name, '/' );
 519     int len = p ? (int)(p - name) : strlen(name);
 520     if ((p = strchr( name, '\\' ))) len = MIN( (int)(p - name), len );
 521     if (long_len < len + 1) return FALSE;
 522
 523     TRACE(dosfs, "%s,%s\n", path, name );
 524
 525     if (!DOSFS_ToDosFCBFormat( name, dos_name )) dos_name[0] = '\0';
 526
 527     if (!(dir = DOSFS_OpenDir( path )))
 528     {
 529         WARN(dosfs, "(%s,%s): can't open dir: %s\n",
 530                        path, name, strerror(errno) );
 531         return FALSE;
 532     }
 533
 534     while ((ret = DOSFS_ReadDir( dir, &long_name, &short_name )))
 535     {
 536         /* Check against Unix name */
 537         if (len == strlen(long_name))
 538         {
 539             if (!ignore_case)
 540             {
 541                 if (!lstrncmp32A( long_name, name, len )) break;
 542             }
 543             else
 544             {
 545                 if (!lstrncmpi32A( long_name, name, len )) break;
 546             }
 547         }
 548         if (dos_name[0])
 549         {
 550             /* Check against hashed DOS name */
 551             if (!short_name)
 552             {
 553                 DOSFS_Hash( long_name, tmp_buf, TRUE, ignore_case );
 554                 short_name = tmp_buf;
 555             }
 556             if (!strcmp( dos_name, short_name )) break;
 557         }
 558     }
 559     if (ret)
 560     {
 561         if (long_buf) strcpy( long_buf, long_name );
 562         if (short_buf)
 563         {
 564             if (short_name)
 565                 DOSFS_ToDosDTAFormat( short_name, short_buf );
 566             else
 567                 DOSFS_Hash( long_name, short_buf, FALSE, ignore_case );
 568         }
 569         TRACE(dosfs, "(%s,%s) -> %s (%s)\n",
 570                      path, name, long_name, short_buf ? short_buf : "***");
 571     }
 572     else
 573         WARN(dosfs, "'%s' not found in '%s'\n", name, path);
 574     DOSFS_CloseDir( dir );
 575     return ret;
 576 }
 577
 578
 579 /***********************************************************************
 580  *           DOSFS_GetDevice
 581  *
 582  * Check if a DOS file name represents a DOS device and return the device.
 583  */
 584 const DOS_DEVICE *DOSFS_GetDevice( const char *name )
 585 {
 586     int i;
 587     const char *p;
 588
 589     if (!name) return NULL; /* if FILE_DupUnixHandle was used */
 590     if (name[0] && (name[1] == ':')) name += 2;
 591     if ((p = strrchr( name, '/' ))) name = p + 1;
 592     if ((p = strrchr( name, '\\' ))) name = p + 1;
 593     for (i = 0; i < sizeof(DOSFS_Devices)/sizeof(DOSFS_Devices[0]); i++)
 594     {
 595         const char *dev = DOSFS_Devices[i].name;
 596         if (!lstrncmpi32A( dev, name, strlen(dev) ))
 597         {
 598             p = name + strlen( dev );
 599             if (!*p || (*p == '.')) return &DOSFS_Devices[i];
 600         }
 601     }
 602     return NULL;
 603 }
 604
 605 /***********************************************************************
 606  *           DOSFS_OpenDevice
 607  *
 608  * Open a DOS device. This might not map 1:1 into the UNIX device concept.
 609  */
 610 HFILE32 DOSFS_OpenDevice( const char *name, int unixmode )
 611 {
 612     int i;
 613     const char *p;
 614     FILE_OBJECT *file;
 615     HFILE32 handle;
 616
 617     if (!name) return (HFILE32)NULL; /* if FILE_DupUnixHandle was used */
 618     if (name[0] && (name[1] == ':')) name += 2;
 619     if ((p = strrchr( name, '/' ))) name = p + 1;
 620     if ((p = strrchr( name, '\\' ))) name = p + 1;
 621     for (i = 0; i < sizeof(DOSFS_Devices)/sizeof(DOSFS_Devices[0]); i++)
 622     {
 623         const char *dev = DOSFS_Devices[i].name;
 624         if (!lstrncmpi32A( dev, name, strlen(dev) ))
 625         {
 626             p = name + strlen( dev );
 627             if (!*p || (*p == '.')) {
 628                 /* got it */
 629                 if (!strcmp(DOSFS_Devices[i].name,"NUL"))
 630                         return FILE_OpenUnixFile("/dev/null",unixmode);
 631                 if (!strcmp(DOSFS_Devices[i].name,"CON")) {
 632                         HFILE32 to_dup;
 633                         HFILE32 handle;
 634                         switch (unixmode) {
 635                         case O_RDONLY:
 636                                 to_dup = GetStdHandle( STD_INPUT_HANDLE );
 637                                 break;
 638                         case O_WRONLY:
 639                                 to_dup = GetStdHandle( STD_OUTPUT_HANDLE );
 640                                 break;
 641                         default:
 642                                 FIXME(dosfs,"can't open CON read/write\n");
 643                                 return HFILE_ERROR32;
 644                                 break;
 645                         }
 646                         if (!DuplicateHandle( GetCurrentProcess(), to_dup, GetCurrentProcess(),
 647                                               &handle, 0, FALSE, DUPLICATE_SAME_ACCESS ))
 648                             handle = HFILE_ERROR32;
 649                         return handle;
 650                 }
 651                 if (!strcmp(DOSFS_Devices[i].name,"SCSIMGR$")) {
 652                         if ((handle = FILE_Alloc( &file )) == INVALID_HANDLE_VALUE32)
 653                                 return HFILE_ERROR32;
 654                         else {
 655                                 file->unix_name = HEAP_strdupA( SystemHeap, 0, name );
 656                                 return handle;
 657                         }
 658                 }
 659                 if (!strcmp(DOSFS_Devices[i].name,"HPSCAN")) {
 660                         if ((handle = FILE_Alloc( &file )) == INVALID_HANDLE_VALUE32)
 661                                 return HFILE_ERROR32;
 662                         else {
 663                                 file->unix_name = HEAP_strdupA( SystemHeap, 0, name );
 664                                 return handle;
 665                         }
 666                 }
 667                 FIXME(dosfs,"device open %s not supported (yet)\n",DOSFS_Devices[i].name);
 668                 return HFILE_ERROR32;
 669             }
 670         }
 671     }
 672     return HFILE_ERROR32;
 673 }
 674
 675
 676 /***********************************************************************
 677  *           DOSFS_GetPathDrive
 678  *
 679  * Get the drive specified by a given path name (DOS or Unix format).
 680  */
 681 static int DOSFS_GetPathDrive( const char **name )
 682 {
 683     int drive;
 684     const char *p = *name;
 685
 686     if (*p && (p[1] == ':'))
 687     {
 688         drive = toupper(*p) - 'A';
 689         *name += 2;
 690     }
 691     else if (*p == '/') /* Absolute Unix path? */
 692     {
 693         if ((drive = DRIVE_FindDriveRoot( name )) == -1)
 694         {
 695             MSG("Warning: %s not accessible from a DOS drive\n", *name );
 696             /* Assume it really was a DOS name */
 697             drive = DRIVE_GetCurrentDrive();
 698         }
 699     }
 700     else drive = DRIVE_GetCurrentDrive();
 701
 702     if (!DRIVE_IsValid(drive))
 703     {
 704         DOS_ERROR( ER_InvalidDrive, EC_MediaError, SA_Abort, EL_Disk );
 705         return -1;
 706     }
 707     return drive;
 708 }
 709
 710
 711 /***********************************************************************
 712  *           DOSFS_GetFullName
 713  *
 714  * Convert a file name (DOS or mixed DOS/Unix format) to a valid
 715  * Unix name / short DOS name pair.
 716  * Return FALSE if one of the path components does not exist. The last path
 717  * component is only checked if 'check_last' is non-zero.
 718  * The buffers pointed to by 'long_buf' and 'short_buf' must be
 719  * at least MAX_PATHNAME_LEN long.
 720  */
 721 BOOL32 DOSFS_GetFullName( LPCSTR name, BOOL32 check_last, DOS_FULL_NAME *full )
 722 {
 723     BOOL32 found;
 724     UINT32 flags;
 725     char *p_l, *p_s, *root;
 726
 727     TRACE(dosfs, "%s (last=%d)\n",
 728                    name, check_last );
 729
 730     if ((full->drive = DOSFS_GetPathDrive( &name )) == -1) return FALSE;
 731     flags = DRIVE_GetFlags( full->drive );
 732
 733     lstrcpyn32A( full->long_name, DRIVE_GetRoot( full->drive ),
 734                  sizeof(full->long_name) );
 735     if (full->long_name[1]) root = full->long_name + strlen(full->long_name);
 736     else root = full->long_name;  /* root directory */
 737
 738     strcpy( full->short_name, "A:\\" );
 739     full->short_name[0] += full->drive;
 740
 741     if ((*name == '\\') || (*name == '/'))  /* Absolute path */
 742     {
 743         while ((*name == '\\') || (*name == '/')) name++;
 744     }
 745     else  /* Relative path */
 746     {
 747         lstrcpyn32A( root + 1, DRIVE_GetUnixCwd( full->drive ),
 748                      sizeof(full->long_name) - (root - full->long_name) - 1 );
 749         if (root[1]) *root = '/';
 750         lstrcpyn32A( full->short_name + 3, DRIVE_GetDosCwd( full->drive ),
 751                      sizeof(full->short_name) - 3 );
 752     }
 753
 754     p_l = full->long_name[1] ? full->long_name + strlen(full->long_name)
 755                              : full->long_name;
 756     p_s = full->short_name[3] ? full->short_name + strlen(full->short_name)
 757                               : full->short_name + 2;
 758     found = TRUE;
 759
 760     while (*name && found)
 761     {
 762         /* Check for '.' and '..' */
 763
 764         if (*name == '.')
 765         {
 766             if (IS_END_OF_NAME(name[1]))
 767             {
 768                 name++;
 769                 while ((*name == '\\') || (*name == '/')) name++;
 770                 continue;
 771             }
 772             else if ((name[1] == '.') && IS_END_OF_NAME(name[2]))
 773             {
 774                 name += 2;
 775                 while ((*name == '\\') || (*name == '/')) name++;
 776                 while ((p_l > root) && (*p_l != '/')) p_l--;
 777                 while ((p_s > full->short_name + 2) && (*p_s != '\\')) p_s--;
 778                 *p_l = *p_s = '\0';  /* Remove trailing separator */
 779                 continue;
 780             }
 781         }
 782
 783         /* Make sure buffers are large enough */
 784
 785         if ((p_s >= full->short_name + sizeof(full->short_name) - 14) ||
 786             (p_l >= full->long_name + sizeof(full->long_name) - 1))
 787         {
 788             DOS_ERROR( ER_PathNotFound, EC_NotFound, SA_Abort, EL_Disk );
 789             return FALSE;
 790         }
 791
 792         /* Get the long and short name matching the file name */
 793
 794         if ((found = DOSFS_FindUnixName( full->long_name, name, p_l + 1,
 795                          sizeof(full->long_name) - (p_l - full->long_name) - 1,
 796                          p_s + 1, !(flags & DRIVE_CASE_SENSITIVE) )))
 797         {
 798             *p_l++ = '/';
 799             p_l   += strlen(p_l);
 800             *p_s++ = '\\';
 801             p_s   += strlen(p_s);
 802             while (!IS_END_OF_NAME(*name)) name++;
 803         }
 804         else if (!check_last)
 805         {
 806             *p_l++ = '/';
 807             *p_s++ = '\\';
 808             while (!IS_END_OF_NAME(*name) &&
 809                    (p_s < full->short_name + sizeof(full->short_name) - 1) &&
 810                    (p_l < full->long_name + sizeof(full->long_name) - 1))
 811             {
 812                 *p_s++ = tolower(*name);
 813                 /* If the drive is case-sensitive we want to create new */
 814                 /* files in lower-case otherwise we can't reopen them   */
 815                 /* under the same short name. */
 816                 if (flags & DRIVE_CASE_SENSITIVE) *p_l++ = tolower(*name);
 817                 else *p_l++ = *name;
 818                 name++;
 819             }
 820             *p_l = *p_s = '\0';
 821         }
 822         while ((*name == '\\') || (*name == '/')) name++;
 823     }
 824
 825     if (!found)
 826     {
 827         if (check_last)
 828         {
 829             DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
 830             return FALSE;
 831         }
 832         if (*name)  /* Not last */
 833         {
 834             DOS_ERROR( ER_PathNotFound, EC_NotFound, SA_Abort, EL_Disk );
 835             return FALSE;
 836         }
 837     }
 838     if (!full->long_name[0]) strcpy( full->long_name, "/" );
 839     if (!full->short_name[2]) strcpy( full->short_name + 2, "\\" );
 840     TRACE(dosfs, "returning %s = %s\n",
 841                    full->long_name, full->short_name );
 842     return TRUE;
 843 }
 844
 845
 846 /***********************************************************************
 847  *           GetShortPathName32A   (KERNEL32.271)
 848  */
 849 DWORD WINAPI GetShortPathName32A( LPCSTR longpath, LPSTR shortpath,
 850                                   DWORD shortlen )
 851 {
 852     DOS_FULL_NAME full_name;
 853
 854     /* FIXME: is it correct to always return a fully qualified short path? */
 855     if (!DOSFS_GetFullName( longpath, TRUE, &full_name )) return 0;
 856     lstrcpyn32A( shortpath, full_name.short_name, shortlen );
 857     return strlen( full_name.short_name );
 858 }
 859
 860
 861 /***********************************************************************
 862  *           GetShortPathName32W   (KERNEL32.272)
 863  */
 864 DWORD WINAPI GetShortPathName32W( LPCWSTR longpath, LPWSTR shortpath,
 865                                   DWORD shortlen )
 866 {
 867     DOS_FULL_NAME full_name;
 868     DWORD ret = 0;
 869     LPSTR longpathA = HEAP_strdupWtoA( GetProcessHeap(), 0, longpath );
 870
 871     /* FIXME: is it correct to always return a fully qualified short path? */
 872     if (DOSFS_GetFullName( longpathA, TRUE, &full_name ))
 873     {
 874         ret = strlen( full_name.short_name );
 875         lstrcpynAtoW( shortpath, full_name.short_name, shortlen );
 876     }
 877     HeapFree( GetProcessHeap(), 0, longpathA );
 878     return ret;
 879 }
 880
 881
 882 /***********************************************************************
 883  *           GetLongPathName32A   (KERNEL32.xxx)
 884  */
 885 DWORD WINAPI GetLongPathName32A( LPCSTR shortpath, LPSTR longpath,
 886                                   DWORD longlen )
 887 {
 888     DOS_FULL_NAME full_name;
 889     char *p;
 890     char *longfilename;
 891     DWORD shortpathlen;
 892
 893     if (!DOSFS_GetFullName( shortpath, TRUE, &full_name )) return 0;
 894     lstrcpyn32A( longpath, full_name.short_name, longlen );
 895     /* Do some hackery to get the long filename.
 896      * FIXME: Would be better if it returned the
 897      * long version of the directories too
 898      */
 899     longfilename = strrchr(full_name.long_name, '/')+1;
 900     if (longpath != NULL) {
 901       if ((p = strrchr( longpath, '\\' )) != NULL) {
 902         p++;
 903         longlen -= (p-longpath);
 904         lstrcpyn32A( p, longfilename , longlen);
 905       }
 906     }
 907     shortpathlen =
 908       ((strrchr( full_name.short_name, '\\' ) - full_name.short_name) + 1);
 909     return shortpathlen + strlen( longfilename );
 910 }
 911
 912
 913 /***********************************************************************
 914  *           GetLongPathName32W   (KERNEL32.269)
 915  */
 916 DWORD WINAPI GetLongPathName32W( LPCWSTR shortpath, LPWSTR longpath,
 917                                   DWORD longlen )
 918 {
 919     DOS_FULL_NAME full_name;
 920     DWORD ret = 0;
 921     LPSTR shortpathA = HEAP_strdupWtoA( GetProcessHeap(), 0, shortpath );
 922
 923     /* FIXME: is it correct to always return a fully qualified short path? */
 924     if (DOSFS_GetFullName( shortpathA, TRUE, &full_name ))
 925     {
 926         ret = strlen( full_name.short_name );
 927         lstrcpynAtoW( longpath, full_name.long_name, longlen );
 928     }
 929     HeapFree( GetProcessHeap(), 0, shortpathA );
 930     return ret;
 931 }
 932
 933
 934 /***********************************************************************
 935  *           DOSFS_DoGetFullPathName
 936  *
 937  * Implementation of GetFullPathName32A/W.
 938  */
 939 static DWORD DOSFS_DoGetFullPathName( LPCSTR name, DWORD len, LPSTR result,
 940                                       BOOL32 unicode )
 941 {
 942     char buffer[MAX_PATHNAME_LEN];
 943     int drive;
 944     char *p;
 945
 946     TRACE(dosfs, "converting %s\n", name );
 947
 948     if (!name || !result) return 0;
 949
 950     if ((drive = DOSFS_GetPathDrive( &name )) == -1) return 0;
 951     p = buffer;
 952     *p++ = 'A' + drive;
 953     *p++ = ':';
 954     if (IS_END_OF_NAME(*name) && (*name))  /* Absolute path */
 955     {
 956         while ((*name == '\\') || (*name == '/')) name++;
 957     }
 958     else  /* Relative path or empty path */
 959     {
 960         *p++ = '\\';
 961         lstrcpyn32A( p, DRIVE_GetDosCwd(drive), sizeof(buffer) - 3 );
 962         if (*p) p += strlen(p); else p--;
 963     }
 964     if (!*name) /* empty path */
 965       *p++ = '\\';
 966     *p = '\0';
 967
 968     while (*name)
 969     {
 970         if (*name == '.')
 971         {
 972             if (IS_END_OF_NAME(name[1]))
 973             {
 974                 name++;
 975                 while ((*name == '\\') || (*name == '/')) name++;
 976                 continue;
 977             }
 978             else if ((name[1] == '.') && IS_END_OF_NAME(name[2]))
 979             {
 980                 name += 2;
 981                 while ((*name == '\\') || (*name == '/')) name++;
 982                 while ((p > buffer + 2) && (*p != '\\')) p--;
 983                 *p = '\0';  /* Remove trailing separator */
 984                 continue;
 985             }
 986         }
 987         if (p >= buffer + sizeof(buffer) - 1)
 988         {
 989             DOS_ERROR( ER_PathNotFound, EC_NotFound, SA_Abort, EL_Disk );
 990             return 0;
 991         }
 992         *p++ = '\\';
 993         while (!IS_END_OF_NAME(*name) && (p < buffer + sizeof(buffer) - 1))
 994             *p++ = *name++;
 995         *p = '\0';
 996         while ((*name == '\\') || (*name == '/')) name++;
 997     }
 998
 999     if (!buffer[2])
1000     {
1001         buffer[2] = '\\';
1002         buffer[3] = '\0';
1003     }
1004     if (!(DRIVE_GetFlags(drive) & DRIVE_CASE_PRESERVING))
1005         CharUpper32A( buffer );
1006
1007     if (unicode) lstrcpynAtoW( (LPWSTR)result, buffer, len );
1008     else lstrcpyn32A( result, buffer, len );
1009
1010     TRACE(dosfs, "returning %s\n", buffer );
1011     return strlen(buffer);
1012 }
1013
1014
1015 /***********************************************************************
1016  *           GetFullPathName32A   (KERNEL32.272)
1017  */
1018 DWORD WINAPI GetFullPathName32A( LPCSTR name, DWORD len, LPSTR buffer,
1019                                  LPSTR *lastpart )
1020 {
1021     DWORD ret = DOSFS_DoGetFullPathName( name, len, buffer, FALSE );
1022     if (ret && lastpart)
1023     {
1024         LPSTR p = buffer + strlen(buffer);
1025         while ((p > buffer + 2) && (*p != '\\')) p--;
1026         *lastpart = p + 1;
1027     }
1028     return ret;
1029 }
1030
1031
1032 /***********************************************************************
1033  *           GetFullPathName32W   (KERNEL32.273)
1034  */
1035 DWORD WINAPI GetFullPathName32W( LPCWSTR name, DWORD len, LPWSTR buffer,
1036                                  LPWSTR *lastpart )
1037 {
1038     LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
1039     DWORD ret = DOSFS_DoGetFullPathName( nameA, len, (LPSTR)buffer, TRUE );
1040     HeapFree( GetProcessHeap(), 0, nameA );
1041     if (ret && lastpart)
1042     {
1043         LPWSTR p = buffer + lstrlen32W(buffer);
1044         while ((p > buffer + 2) && (*p != '\\')) p--;
1045         *lastpart = p + 1;
1046     }
1047     return ret;
1048 }
1049
1050 /***********************************************************************
1051  *           DOSFS_FindNextEx
1052  */
1053 static int DOSFS_FindNextEx( FIND_FIRST_INFO *info, WIN32_FIND_DATA32A *entry )
1054 {
1055     BYTE attr = info->attr | FA_UNUSED | FA_ARCHIVE | FA_RDONLY;
1056     UINT32 flags = DRIVE_GetFlags( info->drive );
1057     char *p, buffer[MAX_PATHNAME_LEN];
1058     const char *drive_path;
1059     int drive_root;
1060     LPCSTR long_name, short_name;
1061     BY_HANDLE_FILE_INFORMATION fileinfo;
1062     char dos_name[13];
1063
1064     if ((info->attr & ~(FA_UNUSED | FA_ARCHIVE | FA_RDONLY)) == FA_LABEL)
1065     {
1066         if (info->cur_pos) return 0;
1067         entry->dwFileAttributes  = FILE_ATTRIBUTE_LABEL;
1068         DOSFS_UnixTimeToFileTime( (time_t)0, &entry->ftCreationTime, 0 );
1069         DOSFS_UnixTimeToFileTime( (time_t)0, &entry->ftLastAccessTime, 0 );
1070         DOSFS_UnixTimeToFileTime( (time_t)0, &entry->ftLastWriteTime, 0 );
1071         entry->nFileSizeHigh     = 0;
1072         entry->nFileSizeLow      = 0;
1073         entry->dwReserved0       = 0;
1074         entry->dwReserved1       = 0;
1075         DOSFS_ToDosDTAFormat( DRIVE_GetLabel( info->drive ), entry->cFileName );
1076         strcpy( entry->cAlternateFileName, entry->cFileName );
1077         info->cur_pos++;
1078         return 1;
1079     }
1080
1081     drive_path = info->path + strlen(DRIVE_GetRoot( info->drive ));
1082     while ((*drive_path == '/') || (*drive_path == '\\')) drive_path++;
1083     drive_root = !*drive_path;
1084
1085     lstrcpyn32A( buffer, info->path, sizeof(buffer) - 1 );
1086     strcat( buffer, "/" );
1087     p = buffer + strlen(buffer);
1088
1089     while (DOSFS_ReadDir( info->dir, &long_name, &short_name ))
1090     {
1091         info->cur_pos++;
1092
1093         /* Don't return '.' and '..' in the root of the drive */
1094         if (drive_root && (long_name[0] == '.') &&
1095             (!long_name[1] || ((long_name[1] == '.') && !long_name[2])))
1096             continue;
1097
1098         /* Check the long mask */
1099
1100         if (info->long_mask)
1101         {
1102             if (!DOSFS_MatchLong( info->long_mask, long_name,
1103                                   flags & DRIVE_CASE_SENSITIVE )) continue;
1104         }
1105
1106         /* Check the short mask */
1107
1108         if (info->short_mask)
1109         {
1110             if (!short_name)
1111             {
1112                 DOSFS_Hash( long_name, dos_name, TRUE,
1113                             !(flags & DRIVE_CASE_SENSITIVE) );
1114                 short_name = dos_name;
1115             }
1116             if (!DOSFS_MatchShort( info->short_mask, short_name )) continue;
1117         }
1118
1119         /* Check the file attributes */
1120
1121         lstrcpyn32A( p, long_name, sizeof(buffer) - (int)(p - buffer) );
1122         if (!FILE_Stat( buffer, &fileinfo ))
1123         {
1124             WARN(dosfs, "can't stat %s\n", buffer);
1125             continue;
1126         }
1127         if (fileinfo.dwFileAttributes & ~attr) continue;
1128
1129         /* We now have a matching entry; fill the result and return */
1130
1131         entry->dwFileAttributes = fileinfo.dwFileAttributes;
1132         entry->ftCreationTime   = fileinfo.ftCreationTime;
1133         entry->ftLastAccessTime = fileinfo.ftLastAccessTime;
1134         entry->ftLastWriteTime  = fileinfo.ftLastWriteTime;
1135         entry->nFileSizeHigh    = fileinfo.nFileSizeHigh;
1136         entry->nFileSizeLow     = fileinfo.nFileSizeLow;
1137
1138         if (short_name)
1139             DOSFS_ToDosDTAFormat( short_name, entry->cAlternateFileName );
1140         else
1141             DOSFS_Hash( long_name, entry->cAlternateFileName, FALSE,
1142                         !(flags & DRIVE_CASE_SENSITIVE) );
1143
1144         lstrcpyn32A( entry->cFileName, long_name, sizeof(entry->cFileName) );
1145         if (!(flags & DRIVE_CASE_PRESERVING)) CharLower32A( entry->cFileName );
1146         TRACE(dosfs, "returning %s (%s) %02lx %ld\n",
1147                        entry->cFileName, entry->cAlternateFileName,
1148                        entry->dwFileAttributes, entry->nFileSizeLow );
1149         return 1;
1150     }
1151     return 0;  /* End of directory */
1152 }
1153
1154 /***********************************************************************
1155  *           DOSFS_FindNext
1156  *
1157  * Find the next matching file. Return the number of entries read to find
1158  * the matching one, or 0 if no more entries.
1159  * 'short_mask' is the 8.3 mask (in FCB format), 'long_mask' is the long
1160  * file name mask. Either or both can be NULL.
1161  *
1162  * NOTE: This is supposed to be only called by the int21 emulation
1163  *       routines. Thus, we should own the Win16Mutex anyway.
1164  *       Nevertheless, we explicitly enter it to ensure the static
1165  *       directory cache is protected.
1166  */
1167 int DOSFS_FindNext( const char *path, const char *short_mask,
1168                     const char *long_mask, int drive, BYTE attr,
1169                     int skip, WIN32_FIND_DATA32A *entry )
1170 {
1171     static FIND_FIRST_INFO info = { NULL };
1172     LPCSTR short_name, long_name;
1173     int count;
1174
1175     SYSLEVEL_EnterWin16Lock();
1176
1177     /* Check the cached directory */
1178     if (!(info.dir && info.path == path && info.short_mask == short_mask
1179                    && info.long_mask == long_mask && info.drive == drive
1180                    && info.attr == attr && info.cur_pos <= skip))
1181     {
1182         /* Not in the cache, open it anew */
1183         if (info.dir) DOSFS_CloseDir( info.dir );
1184
1185         info.path = (LPSTR)path;
1186         info.long_mask = (LPSTR)long_mask;
1187         info.short_mask = (LPSTR)short_mask;
1188         info.attr = attr;
1189         info.drive = drive;
1190         info.cur_pos = 0;
1191         info.dir = DOSFS_OpenDir( info.path );
1192     }
1193
1194     /* Skip to desired position */
1195     while (info.cur_pos < skip)
1196         if (info.dir && DOSFS_ReadDir( info.dir, &long_name, &short_name ))
1197             info.cur_pos++;
1198         else
1199             break;
1200
1201     if (info.dir && info.cur_pos == skip && DOSFS_FindNextEx( &info, entry ))
1202         count = info.cur_pos - skip;
1203     else
1204         count = 0;
1205
1206     if (!count)
1207     {
1208         if (info.dir) DOSFS_CloseDir( info.dir );
1209         memset( &info, '\0', sizeof(info) );
1210     }
1211
1212     SYSLEVEL_LeaveWin16Lock();
1213
1214     return count;
1215 }
1216
1217
1218
1219 /*************************************************************************
1220  *           FindFirstFile16   (KERNEL.413)
1221  */
1222 HANDLE16 WINAPI FindFirstFile16( LPCSTR path, WIN32_FIND_DATA32A *data )
1223 {
1224     DOS_FULL_NAME full_name;
1225     HGLOBAL16 handle;
1226     FIND_FIRST_INFO *info;
1227
1228     data->dwReserved0 = data->dwReserved1 = 0x0;
1229     if (!path) return 0;
1230     if (!DOSFS_GetFullName( path, FALSE, &full_name ))
1231         return INVALID_HANDLE_VALUE16;
1232     if (!(handle = GlobalAlloc16( GMEM_MOVEABLE, sizeof(FIND_FIRST_INFO) )))
1233         return INVALID_HANDLE_VALUE16;
1234     info = (FIND_FIRST_INFO *)GlobalLock16( handle );
1235     info->path = HEAP_strdupA( SystemHeap, 0, full_name.long_name );
1236     info->long_mask = strrchr( info->path, '/' );
1237     *(info->long_mask++) = '\0';
1238     info->short_mask = NULL;
1239     info->attr = 0xff;
1240     if (path[0] && (path[1] == ':')) info->drive = toupper(*path) - 'A';
1241     else info->drive = DRIVE_GetCurrentDrive();
1242     info->cur_pos = 0;
1243
1244     info->dir = DOSFS_OpenDir( info->path );
1245
1246     GlobalUnlock16( handle );
1247     if (!FindNextFile16( handle, data ))
1248     {
1249         FindClose16( handle );
1250         DOS_ERROR( ER_NoMoreFiles, EC_MediaError, SA_Abort, EL_Disk );
1251         return INVALID_HANDLE_VALUE16;
1252     }
1253     return handle;
1254 }
1255
1256
1257 /*************************************************************************
1258  *           FindFirstFile32A   (KERNEL32.123)
1259  */
1260 HANDLE32 WINAPI FindFirstFile32A( LPCSTR path, WIN32_FIND_DATA32A *data )
1261 {
1262     HANDLE32 handle = FindFirstFile16( path, data );
1263     if (handle == INVALID_HANDLE_VALUE16) return INVALID_HANDLE_VALUE32;
1264     return handle;
1265 }
1266
1267
1268 /*************************************************************************
1269  *           FindFirstFile32W   (KERNEL32.124)
1270  */
1271 HANDLE32 WINAPI FindFirstFile32W( LPCWSTR path, WIN32_FIND_DATA32W *data )
1272 {
1273     WIN32_FIND_DATA32A dataA;
1274     LPSTR pathA = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
1275     HANDLE32 handle = FindFirstFile32A( pathA, &dataA );
1276     HeapFree( GetProcessHeap(), 0, pathA );
1277     if (handle != INVALID_HANDLE_VALUE32)
1278     {
1279         data->dwFileAttributes = dataA.dwFileAttributes;
1280         data->ftCreationTime   = dataA.ftCreationTime;
1281         data->ftLastAccessTime = dataA.ftLastAccessTime;
1282         data->ftLastWriteTime  = dataA.ftLastWriteTime;
1283         data->nFileSizeHigh    = dataA.nFileSizeHigh;
1284         data->nFileSizeLow     = dataA.nFileSizeLow;
1285         lstrcpyAtoW( data->cFileName, dataA.cFileName );
1286         lstrcpyAtoW( data->cAlternateFileName, dataA.cAlternateFileName );
1287     }
1288     return handle;
1289 }
1290
1291
1292 /*************************************************************************
1293  *           FindNextFile16   (KERNEL.414)
1294  */
1295 BOOL16 WINAPI FindNextFile16( HANDLE16 handle, WIN32_FIND_DATA32A *data )
1296 {
1297     FIND_FIRST_INFO *info;
1298
1299     if (!(info = (FIND_FIRST_INFO *)GlobalLock16( handle )))
1300     {
1301         DOS_ERROR( ER_InvalidHandle, EC_ProgramError, SA_Abort, EL_Disk );
1302         return FALSE;
1303     }
1304     GlobalUnlock16( handle );
1305     if (!info->path || !info->dir)
1306     {
1307         DOS_ERROR( ER_NoMoreFiles, EC_MediaError, SA_Abort, EL_Disk );
1308         return FALSE;
1309     }
1310     if (!DOSFS_FindNextEx( info, data ))
1311     {
1312         DOSFS_CloseDir( info->dir ); info->dir = NULL;
1313         HeapFree( SystemHeap, 0, info->path );
1314         info->path = info->long_mask = NULL;
1315         DOS_ERROR( ER_NoMoreFiles, EC_MediaError, SA_Abort, EL_Disk );
1316         return FALSE;
1317     }
1318     return TRUE;
1319 }
1320
1321
1322 /*************************************************************************
1323  *           FindNextFile32A   (KERNEL32.126)
1324  */
1325 BOOL32 WINAPI FindNextFile32A( HANDLE32 handle, WIN32_FIND_DATA32A *data )
1326 {
1327     return FindNextFile16( handle, data );
1328 }
1329
1330
1331 /*************************************************************************
1332  *           FindNextFile32W   (KERNEL32.127)
1333  */
1334 BOOL32 WINAPI FindNextFile32W( HANDLE32 handle, WIN32_FIND_DATA32W *data )
1335 {
1336     WIN32_FIND_DATA32A dataA;
1337     if (!FindNextFile32A( handle, &dataA )) return FALSE;
1338     data->dwFileAttributes = dataA.dwFileAttributes;
1339     data->ftCreationTime   = dataA.ftCreationTime;
1340     data->ftLastAccessTime = dataA.ftLastAccessTime;
1341     data->ftLastWriteTime  = dataA.ftLastWriteTime;
1342     data->nFileSizeHigh    = dataA.nFileSizeHigh;
1343     data->nFileSizeLow     = dataA.nFileSizeLow;
1344     lstrcpyAtoW( data->cFileName, dataA.cFileName );
1345     lstrcpyAtoW( data->cAlternateFileName, dataA.cAlternateFileName );
1346     return TRUE;
1347 }
1348
1349
1350 /*************************************************************************
1351  *           FindClose16   (KERNEL.415)
1352  */
1353 BOOL16 WINAPI FindClose16( HANDLE16 handle )
1354 {
1355     FIND_FIRST_INFO *info;
1356
1357     if ((handle == INVALID_HANDLE_VALUE16) ||
1358         !(info = (FIND_FIRST_INFO *)GlobalLock16( handle )))
1359     {
1360         DOS_ERROR( ER_InvalidHandle, EC_ProgramError, SA_Abort, EL_Disk );
1361         return FALSE;
1362     }
1363     if (info->dir) DOSFS_CloseDir( info->dir );
1364     if (info->path) HeapFree( SystemHeap, 0, info->path );
1365     GlobalUnlock16( handle );
1366     GlobalFree16( handle );
1367     return TRUE;
1368 }
1369
1370
1371 /*************************************************************************
1372  *           FindClose32   (KERNEL32.119)
1373  */
1374 BOOL32 WINAPI FindClose32( HANDLE32 handle )
1375 {
1376     return FindClose16( (HANDLE16)handle );
1377 }
1378
1379
1380 /***********************************************************************
1381  *           DOSFS_UnixTimeToFileTime
1382  *
1383  * Convert a Unix time to FILETIME format.
1384  * The FILETIME structure is a 64-bit value representing the number of
1385  * 100-nanosecond intervals since January 1, 1601, 0:00.
1386  * 'remainder' is the nonnegative number of 100-ns intervals
1387  * corresponding to the time fraction smaller than 1 second that
1388  * couldn't be stored in the time_t value.
1389  */
1390 void DOSFS_UnixTimeToFileTime( time_t unix_time, FILETIME *filetime,
1391                                DWORD remainder )
1392 {
1393     /* NOTES:
1394
1395        CONSTANTS:
1396        The time difference between 1 January 1601, 00:00:00 and
1397        1 January 1970, 00:00:00 is 369 years, plus the leap years
1398        from 1604 to 1968, excluding 1700, 1800, 1900.
1399        This makes (1968 - 1600) / 4 - 3 = 89 leap days, and a total
1400        of 134774 days.
1401
1402        Any day in that period had 24 * 60 * 60 = 86400 seconds.
1403
1404        The time difference is 134774 * 86400 * 10000000, which can be written
1405        116444736000000000
1406        27111902 * 2^32 + 3577643008
1407        413 * 2^48 + 45534 * 2^32 + 54590 * 2^16 + 32768
1408
1409        If you find that these constants are buggy, please change them in all
1410        instances in both conversion functions.
1411
1412        VERSIONS:
1413        There are two versions, one of them uses long long variables and
1414        is presumably faster but not ISO C. The other one uses standard C
1415        data types and operations but relies on the assumption that negative
1416        numbers are stored as 2's complement (-1 is 0xffff....). If this
1417        assumption is violated, dates before 1970 will not convert correctly.
1418        This should however work on any reasonable architecture where WINE
1419        will run.
1420
1421        DETAILS:
1422
1423        Take care not to remove the casts. I have tested these functions
1424        (in both versions) for a lot of numbers. I would be interested in
1425        results on other compilers than GCC.
1426
1427        The operations have been designed to account for the possibility
1428        of 64-bit time_t in future UNICES. Even the versions without
1429        internal long long numbers will work if time_t only is 64 bit.
1430        A 32-bit shift, which was necessary for that operation, turned out
1431        not to work correctly in GCC, besides giving the warning. So I
1432        used a double 16-bit shift instead. Numbers are in the ISO version
1433        represented by three limbs, the most significant with 32 bit, the
1434        other two with 16 bit each.
1435
1436        As the modulo-operator % is not well-defined for negative numbers,
1437        negative divisors have been avoided in DOSFS_FileTimeToUnixTime.
1438
1439        There might be quicker ways to do this in C. Certainly so in
1440        assembler.
1441
1442        Claus Fischer, fischer@iue.tuwien.ac.at
1443        */
1444
1445 #if (SIZEOF_LONG_LONG >= 8)
1446 #  define USE_LONG_LONG 1
1447 #else
1448 #  define USE_LONG_LONG 0
1449 #endif
1450
1451 #if USE_LONG_LONG               /* gcc supports long long type */
1452
1453     long long int t = unix_time;
1454     t *= 10000000;
1455     t += 116444736000000000LL;
1456     t += remainder;
1457     filetime->dwLowDateTime  = (UINT32)t;
1458     filetime->dwHighDateTime = (UINT32)(t >> 32);
1459
1460 #else  /* ISO version */
1461
1462     UINT32 a0;                  /* 16 bit, low    bits */
1463     UINT32 a1;                  /* 16 bit, medium bits */
1464     UINT32 a2;                  /* 32 bit, high   bits */
1465
1466     /* Copy the unix time to a2/a1/a0 */
1467     a0 =  unix_time & 0xffff;
1468     a1 = (unix_time >> 16) & 0xffff;
1469     /* This is obsolete if unix_time is only 32 bits, but it does not hurt.
1470        Do not replace this by >> 32, it gives a compiler warning and it does
1471        not work. */
1472     a2 = (unix_time >= 0 ? (unix_time >> 16) >> 16 :
1473           ~((~unix_time >> 16) >> 16));
1474
1475     /* Multiply a by 10000000 (a = a2/a1/a0)
1476        Split the factor into 10000 * 1000 which are both less than 0xffff. */
1477     a0 *= 10000;
1478     a1 = a1 * 10000 + (a0 >> 16);
1479     a2 = a2 * 10000 + (a1 >> 16);
1480     a0 &= 0xffff;
1481     a1 &= 0xffff;
1482
1483     a0 *= 1000;
1484     a1 = a1 * 1000 + (a0 >> 16);
1485     a2 = a2 * 1000 + (a1 >> 16);
1486     a0 &= 0xffff;
1487     a1 &= 0xffff;
1488
1489     /* Add the time difference and the remainder */
1490     a0 += 32768 + (remainder & 0xffff);
1491     a1 += 54590 + (remainder >> 16   ) + (a0 >> 16);
1492     a2 += 27111902                     + (a1 >> 16);
1493     a0 &= 0xffff;
1494     a1 &= 0xffff;
1495
1496     /* Set filetime */
1497     filetime->dwLowDateTime  = (a1 << 16) + a0;
1498     filetime->dwHighDateTime = a2;
1499 #endif
1500 }
1501
1502
1503 /***********************************************************************
1504  *           DOSFS_FileTimeToUnixTime
1505  *
1506  * Convert a FILETIME format to Unix time.
1507  * If not NULL, 'remainder' contains the fractional part of the filetime,
1508  * in the range of [0..9999999] (even if time_t is negative).
1509  */
1510 time_t DOSFS_FileTimeToUnixTime( const FILETIME *filetime, DWORD *remainder )
1511 {
1512     /* Read the comment in the function DOSFS_UnixTimeToFileTime. */
1513 #if USE_LONG_LONG
1514
1515     long long int t = filetime->dwHighDateTime;
1516     t <<= 32;
1517     t += (UINT32)filetime->dwLowDateTime;
1518     t -= 116444736000000000LL;
1519     if (t < 0)
1520     {
1521         if (remainder) *remainder = 9999999 - (-t - 1) % 10000000;
1522         return -1 - ((-t - 1) / 10000000);
1523     }
1524     else
1525     {
1526         if (remainder) *remainder = t % 10000000;
1527         return t / 10000000;
1528     }
1529
1530 #else  /* ISO version */
1531
1532     UINT32 a0;                  /* 16 bit, low    bits */
1533     UINT32 a1;                  /* 16 bit, medium bits */
1534     UINT32 a2;                  /* 32 bit, high   bits */
1535     UINT32 r;                   /* remainder of division */
1536     unsigned int carry;         /* carry bit for subtraction */
1537     int negative;               /* whether a represents a negative value */
1538
1539     /* Copy the time values to a2/a1/a0 */
1540     a2 =  (UINT32)filetime->dwHighDateTime;
1541     a1 = ((UINT32)filetime->dwLowDateTime ) >> 16;
1542     a0 = ((UINT32)filetime->dwLowDateTime ) & 0xffff;
1543
1544     /* Subtract the time difference */
1545     if (a0 >= 32768           ) a0 -=             32768        , carry = 0;
1546     else                        a0 += (1 << 16) - 32768        , carry = 1;
1547
1548     if (a1 >= 54590    + carry) a1 -=             54590 + carry, carry = 0;
1549     else                        a1 += (1 << 16) - 54590 - carry, carry = 1;
1550
1551     a2 -= 27111902 + carry;
1552
1553     /* If a is negative, replace a by (-1-a) */
1554     negative = (a2 >= ((UINT32)1) << 31);
1555     if (negative)
1556     {
1557         /* Set a to -a - 1 (a is a2/a1/a0) */
1558         a0 = 0xffff - a0;
1559         a1 = 0xffff - a1;
1560         a2 = ~a2;
1561     }
1562
1563     /* Divide a by 10000000 (a = a2/a1/a0), put the rest into r.
1564        Split the divisor into 10000 * 1000 which are both less than 0xffff. */
1565     a1 += (a2 % 10000) << 16;
1566     a2 /=       10000;
1567     a0 += (a1 % 10000) << 16;
1568     a1 /=       10000;
1569     r   =  a0 % 10000;
1570     a0 /=       10000;
1571
1572     a1 += (a2 % 1000) << 16;
1573     a2 /=       1000;
1574     a0 += (a1 % 1000) << 16;
1575     a1 /=       1000;
1576     r  += (a0 % 1000) * 10000;
1577     a0 /=       1000;
1578
1579     /* If a was negative, replace a by (-1-a) and r by (9999999 - r) */
1580     if (negative)
1581     {
1582         /* Set a to -a - 1 (a is a2/a1/a0) */
1583         a0 = 0xffff - a0;
1584         a1 = 0xffff - a1;
1585         a2 = ~a2;
1586
1587         r  = 9999999 - r;
1588     }
1589
1590     if (remainder) *remainder = r;
1591
1592     /* Do not replace this by << 32, it gives a compiler warning and it does
1593        not work. */
1594     return ((((time_t)a2) << 16) << 16) + (a1 << 16) + a0;
1595 #endif
1596 }
1597
1598
1599 /***********************************************************************
1600  *           DosDateTimeToFileTime   (KERNEL32.76)
1601  */
1602 BOOL32 WINAPI DosDateTimeToFileTime( WORD fatdate, WORD fattime, LPFILETIME ft)
1603 {
1604     struct tm newtm;
1605
1606     newtm.tm_sec  = (fattime & 0x1f) * 2;
1607     newtm.tm_min  = (fattime >> 5) & 0x3f;
1608     newtm.tm_hour = (fattime >> 11);
1609     newtm.tm_mday = (fatdate & 0x1f);
1610     newtm.tm_mon  = ((fatdate >> 5) & 0x0f) - 1;
1611     newtm.tm_year = (fatdate >> 9) + 80;
1612     DOSFS_UnixTimeToFileTime( mktime( &newtm ), ft, 0 );
1613     return TRUE;
1614 }
1615
1616
1617 /***********************************************************************
1618  *           FileTimeToDosDateTime   (KERNEL32.111)
1619  */
1620 BOOL32 WINAPI FileTimeToDosDateTime( const FILETIME *ft, LPWORD fatdate,
1621                                      LPWORD fattime )
1622 {
1623     time_t unixtime = DOSFS_FileTimeToUnixTime( ft, NULL );
1624     struct tm *tm = localtime( &unixtime );
1625     if (fattime)
1626         *fattime = (tm->tm_hour << 11) + (tm->tm_min << 5) + (tm->tm_sec / 2);
1627     if (fatdate)
1628         *fatdate = ((tm->tm_year - 80) << 9) + ((tm->tm_mon + 1) << 5)
1629                    + tm->tm_mday;
1630     return TRUE;
1631 }
1632
1633
1634 /***********************************************************************
1635  *           LocalFileTimeToFileTime   (KERNEL32.373)
1636  */
1637 BOOL32 WINAPI LocalFileTimeToFileTime( const FILETIME *localft,
1638                                        LPFILETIME utcft )
1639 {
1640     struct tm *xtm;
1641     DWORD remainder;
1642
1643     /* convert from local to UTC. Perhaps not correct. FIXME */
1644     time_t unixtime = DOSFS_FileTimeToUnixTime( localft, &remainder );
1645     xtm = gmtime( &unixtime );
1646     DOSFS_UnixTimeToFileTime( mktime(xtm), utcft, remainder );
1647     return TRUE;
1648 }
1649
1650
1651 /***********************************************************************
1652  *           FileTimeToLocalFileTime   (KERNEL32.112)
1653  */
1654 BOOL32 WINAPI FileTimeToLocalFileTime( const FILETIME *utcft,
1655                                        LPFILETIME localft )
1656 {
1657     DWORD remainder;
1658     /* convert from UTC to local. Perhaps not correct. FIXME */
1659     time_t unixtime = DOSFS_FileTimeToUnixTime( utcft, &remainder );
1660 #ifdef HAVE_TIMEGM
1661     struct tm *xtm = localtime( &unixtime );
1662     time_t localtime;
1663
1664     localtime = timegm(xtm);
1665     DOSFS_UnixTimeToFileTime( localtime, localft, remainder );
1666
1667 #else
1668     struct tm *xtm,*gtm;
1669     time_t time1,time2;
1670
1671     xtm = localtime( &unixtime );
1672     gtm = gmtime( &unixtime );
1673     time1 = mktime(xtm);
1674     time2 = mktime(gtm);
1675     DOSFS_UnixTimeToFileTime( 2*time1-time2, localft, remainder );
1676 #endif
1677     return TRUE;
1678 }
1679
1680
1681 /***********************************************************************
1682  *           FileTimeToSystemTime   (KERNEL32.113)
1683  */
1684 BOOL32 WINAPI FileTimeToSystemTime( const FILETIME *ft, LPSYSTEMTIME syst )
1685 {
1686     struct tm *xtm;
1687     DWORD remainder;
1688     time_t xtime = DOSFS_FileTimeToUnixTime( ft, &remainder );
1689     xtm = gmtime(&xtime);
1690     syst->wYear         = xtm->tm_year+1900;
1691     syst->wMonth        = xtm->tm_mon + 1;
1692     syst->wDayOfWeek    = xtm->tm_wday;
1693     syst->wDay          = xtm->tm_mday;
1694     syst->wHour         = xtm->tm_hour;
1695     syst->wMinute       = xtm->tm_min;
1696     syst->wSecond       = xtm->tm_sec;
1697     syst->wMilliseconds = remainder / 10000;
1698     return TRUE;
1699 }
1700
1701 /***********************************************************************
1702  *           QueryDosDeviceA   (KERNEL32.413)
1703  *
1704  * returns array of strings terminated by \0, terminated by \0
1705  */
1706 DWORD WINAPI QueryDosDevice32A(LPCSTR devname,LPSTR target,DWORD bufsize)
1707 {
1708     LPSTR s;
1709     char  buffer[200];
1710
1711     TRACE(dosfs,"(%s,...)\n",devname?devname:"<null>");
1712     if (!devname) {
1713         /* return known MSDOS devices */
1714         lstrcpy32A(buffer,"CON COM1 COM2 LPT1 NUL ");
1715         while ((s=strchr(buffer,' ')))
1716                 *s='\0';
1717
1718         lstrcpyn32A(target,buffer,bufsize);
1719         return strlen(buffer);
1720     }
1721     lstrcpy32A(buffer,"\\DEV\\");
1722     lstrcat32A(buffer,devname);
1723     if ((s=strchr(buffer,':'))) *s='\0';
1724     lstrcpyn32A(target,buffer,bufsize);
1725     return strlen(buffer);
1726 }
1727
1728
1729 /***********************************************************************
1730  *           QueryDosDeviceW   (KERNEL32.414)
1731  *
1732  * returns array of strings terminated by \0, terminated by \0
1733  */
1734 DWORD WINAPI QueryDosDevice32W(LPCWSTR devname,LPWSTR target,DWORD bufsize)
1735 {
1736     LPSTR devnameA = devname?HEAP_strdupWtoA(GetProcessHeap(),0,devname):NULL;
1737     LPSTR targetA = (LPSTR)HEAP_xalloc(GetProcessHeap(),0,bufsize);
1738     DWORD ret = QueryDosDevice32A(devnameA,targetA,bufsize);
1739
1740     lstrcpynAtoW(target,targetA,bufsize);
1741     if (devnameA) HeapFree(GetProcessHeap(),0,devnameA);
1742     if (targetA) HeapFree(GetProcessHeap(),0,targetA);
1743     return ret;
1744 }
1745
1746
1747 /***********************************************************************
1748  *           SystemTimeToFileTime   (KERNEL32.526)
1749  */
1750 BOOL32 WINAPI SystemTimeToFileTime( const SYSTEMTIME *syst, LPFILETIME ft )
1751 {
1752 #ifdef HAVE_TIMEGM
1753     struct tm xtm;
1754     time_t utctime;
1755 #else
1756     struct tm xtm,*local_tm,*utc_tm;
1757     time_t localtim,utctime;
1758 #endif
1759
1760     xtm.tm_year = syst->wYear-1900;
1761     xtm.tm_mon  = syst->wMonth - 1;
1762     xtm.tm_wday = syst->wDayOfWeek;
1763     xtm.tm_mday = syst->wDay;
1764     xtm.tm_hour = syst->wHour;
1765     xtm.tm_min  = syst->wMinute;
1766     xtm.tm_sec  = syst->wSecond; /* this is UTC */
1767     xtm.tm_isdst = -1;
1768 #ifdef HAVE_TIMEGM
1769     utctime = timegm(&xtm);
1770     DOSFS_UnixTimeToFileTime( utctime, ft,
1771                               syst->wMilliseconds * 10000 );
1772 #else
1773     localtim = mktime(&xtm);    /* now we've got local time */
1774     local_tm = localtime(&localtim);
1775     utc_tm = gmtime(&localtim);
1776     utctime = mktime(utc_tm);
1777     DOSFS_UnixTimeToFileTime( 2*localtim -utctime, ft,
1778                               syst->wMilliseconds * 10000 );
1779 #endif
1780     return TRUE;
1781 }
1782
1783 BOOL32 WINAPI DefineDosDevice32A(DWORD flags,LPCSTR devname,LPCSTR targetpath) {
1784         FIXME(dosfs,"(0x%08lx,%s,%s),stub!\n",flags,devname,targetpath);
1785         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1786         return FALSE;
1787 }