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, -1 )) == 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, -1 )) == 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  * NOTES
 850  *  observed:
 851  *  longpath=NULL: LastError=ERROR_INVALID_PARAMETER, ret=0
 852  *  *longpath="" or invalid: LastError=ERROR_BAD_PATHNAME, ret=0
 853  */
 854 DWORD WINAPI GetShortPathName32A( LPCSTR longpath, LPSTR shortpath,
 855                                   DWORD shortlen )
 856 {
 857     DOS_FULL_NAME full_name;
 858
 859     if (!longpath)
 860     {
 861         SetLastError(ERROR_INVALID_PARAMETER);
 862         return 0;
 863     }
 864
 865     if (!longpath[0])
 866     {
 867         SetLastError(ERROR_BAD_PATHNAME);
 868         return 0;
 869     }
 870
 871     /* FIXME: is it correct to always return a fully qualified short path? */
 872     if (!DOSFS_GetFullName( longpath, TRUE, &full_name ))
 873     {
 874         SetLastError(ERROR_BAD_PATHNAME);
 875         return 0;
 876     }
 877     lstrcpyn32A( shortpath, full_name.short_name, shortlen );
 878     return strlen( full_name.short_name );
 879 }
 880
 881
 882 /***********************************************************************
 883  *           GetShortPathName32W   (KERNEL32.272)
 884  */
 885 DWORD WINAPI GetShortPathName32W( LPCWSTR longpath, LPWSTR shortpath,
 886                                   DWORD shortlen )
 887 {
 888     DOS_FULL_NAME full_name;
 889     LPSTR longpathA ;
 890     DWORD ret = 0;
 891
 892     if (!longpath)
 893     { SetLastError(ERROR_INVALID_PARAMETER);
 894       return 0;
 895     }
 896
 897     if (!longpath[0])
 898     { SetLastError(ERROR_BAD_PATHNAME);
 899       return 0;
 900     }
 901
 902
 903     longpathA = HEAP_strdupWtoA( GetProcessHeap(), 0, longpath );
 904
 905     /* FIXME: is it correct to always return a fully qualified short path? */
 906     if (DOSFS_GetFullName( longpathA, TRUE, &full_name ))
 907     {
 908         ret = strlen( full_name.short_name );
 909         lstrcpynAtoW( shortpath, full_name.short_name, shortlen );
 910     }
 911
 912     SetLastError(ERROR_BAD_PATHNAME);
 913     HeapFree( GetProcessHeap(), 0, longpathA );
 914     return 0;
 915 }
 916
 917
 918 /***********************************************************************
 919  *           GetLongPathName32A   (KERNEL32.xxx)
 920  */
 921 DWORD WINAPI GetLongPathName32A( LPCSTR shortpath, LPSTR longpath,
 922                                   DWORD longlen )
 923 {
 924     DOS_FULL_NAME full_name;
 925     char *p;
 926     char *longfilename;
 927     DWORD shortpathlen;
 928
 929     if (!DOSFS_GetFullName( shortpath, TRUE, &full_name )) return 0;
 930     lstrcpyn32A( longpath, full_name.short_name, longlen );
 931     /* Do some hackery to get the long filename.
 932      * FIXME: Would be better if it returned the
 933      * long version of the directories too
 934      */
 935     longfilename = strrchr(full_name.long_name, '/')+1;
 936     if (longpath != NULL) {
 937       if ((p = strrchr( longpath, '\\' )) != NULL) {
 938         p++;
 939         longlen -= (p-longpath);
 940         lstrcpyn32A( p, longfilename , longlen);
 941       }
 942     }
 943     shortpathlen =
 944       ((strrchr( full_name.short_name, '\\' ) - full_name.short_name) + 1);
 945     return shortpathlen + strlen( longfilename );
 946 }
 947
 948
 949 /***********************************************************************
 950  *           GetLongPathName32W   (KERNEL32.269)
 951  */
 952 DWORD WINAPI GetLongPathName32W( LPCWSTR shortpath, LPWSTR longpath,
 953                                   DWORD longlen )
 954 {
 955     DOS_FULL_NAME full_name;
 956     DWORD ret = 0;
 957     LPSTR shortpathA = HEAP_strdupWtoA( GetProcessHeap(), 0, shortpath );
 958
 959     /* FIXME: is it correct to always return a fully qualified short path? */
 960     if (DOSFS_GetFullName( shortpathA, TRUE, &full_name ))
 961     {
 962         ret = strlen( full_name.short_name );
 963         lstrcpynAtoW( longpath, full_name.long_name, longlen );
 964     }
 965     HeapFree( GetProcessHeap(), 0, shortpathA );
 966     return ret;
 967 }
 968
 969
 970 /***********************************************************************
 971  *           DOSFS_DoGetFullPathName
 972  *
 973  * Implementation of GetFullPathName32A/W.
 974  */
 975 static DWORD DOSFS_DoGetFullPathName( LPCSTR name, DWORD len, LPSTR result,
 976                                       BOOL32 unicode )
 977 {
 978     char buffer[MAX_PATHNAME_LEN];
 979     int drive;
 980     char *p;
 981
 982     TRACE(dosfs, "converting %s\n", name );
 983
 984     if (!name || !result) return 0;
 985
 986     if ((drive = DOSFS_GetPathDrive( &name )) == -1) return 0;
 987     p = buffer;
 988     *p++ = 'A' + drive;
 989     *p++ = ':';
 990     if (IS_END_OF_NAME(*name) && (*name))  /* Absolute path */
 991     {
 992         while ((*name == '\\') || (*name == '/')) name++;
 993     }
 994     else  /* Relative path or empty path */
 995     {
 996         *p++ = '\\';
 997         lstrcpyn32A( p, DRIVE_GetDosCwd(drive), sizeof(buffer) - 3 );
 998         if (*p) p += strlen(p); else p--;
 999     }
1000     if (!*name) /* empty path */
1001       *p++ = '\\';
1002     *p = '\0';
1003
1004     while (*name)
1005     {
1006         if (*name == '.')
1007         {
1008             if (IS_END_OF_NAME(name[1]))
1009             {
1010                 name++;
1011                 while ((*name == '\\') || (*name == '/')) name++;
1012                 continue;
1013             }
1014             else if ((name[1] == '.') && IS_END_OF_NAME(name[2]))
1015             {
1016                 name += 2;
1017                 while ((*name == '\\') || (*name == '/')) name++;
1018                 while ((p > buffer + 2) && (*p != '\\')) p--;
1019                 *p = '\0';  /* Remove trailing separator */
1020                 continue;
1021             }
1022         }
1023         if (p >= buffer + sizeof(buffer) - 1)
1024         {
1025             DOS_ERROR( ER_PathNotFound, EC_NotFound, SA_Abort, EL_Disk );
1026             return 0;
1027         }
1028         *p++ = '\\';
1029         while (!IS_END_OF_NAME(*name) && (p < buffer + sizeof(buffer) - 1))
1030             *p++ = *name++;
1031         *p = '\0';
1032         while ((*name == '\\') || (*name == '/')) name++;
1033     }
1034
1035     if (!buffer[2])
1036     {
1037         buffer[2] = '\\';
1038         buffer[3] = '\0';
1039     }
1040     if (!(DRIVE_GetFlags(drive) & DRIVE_CASE_PRESERVING))
1041         CharUpper32A( buffer );
1042
1043     if (unicode) lstrcpynAtoW( (LPWSTR)result, buffer, len );
1044     else lstrcpyn32A( result, buffer, len );
1045
1046     TRACE(dosfs, "returning %s\n", buffer );
1047     return strlen(buffer);
1048 }
1049
1050
1051 /***********************************************************************
1052  *           GetFullPathName32A   (KERNEL32.272)
1053  */
1054 DWORD WINAPI GetFullPathName32A( LPCSTR name, DWORD len, LPSTR buffer,
1055                                  LPSTR *lastpart )
1056 {
1057     DWORD ret = DOSFS_DoGetFullPathName( name, len, buffer, FALSE );
1058     if (ret && lastpart)
1059     {
1060         LPSTR p = buffer + strlen(buffer);
1061
1062         /* if the path closed with '\', *lastpart is 0 */
1063         if (*p != '\\')
1064         {
1065           while ((p > buffer + 2) && (*p != '\\')) p--;
1066           *lastpart = p + 1;
1067         }
1068         else *lastpart = NULL;
1069     }
1070     return ret;
1071 }
1072
1073
1074 /***********************************************************************
1075  *           GetFullPathName32W   (KERNEL32.273)
1076  */
1077 DWORD WINAPI GetFullPathName32W( LPCWSTR name, DWORD len, LPWSTR buffer,
1078                                  LPWSTR *lastpart )
1079 {
1080     LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
1081     DWORD ret = DOSFS_DoGetFullPathName( nameA, len, (LPSTR)buffer, TRUE );
1082     HeapFree( GetProcessHeap(), 0, nameA );
1083     if (ret && lastpart)
1084     {
1085         LPWSTR p = buffer + lstrlen32W(buffer);
1086         while ((p > buffer + 2) && (*p != '\\')) p--;
1087         *lastpart = p + 1;
1088     }
1089     return ret;
1090 }
1091
1092 /***********************************************************************
1093  *           DOSFS_FindNextEx
1094  */
1095 static int DOSFS_FindNextEx( FIND_FIRST_INFO *info, WIN32_FIND_DATA32A *entry )
1096 {
1097     BYTE attr = info->attr | FA_UNUSED | FA_ARCHIVE | FA_RDONLY;
1098     UINT32 flags = DRIVE_GetFlags( info->drive );
1099     char *p, buffer[MAX_PATHNAME_LEN];
1100     const char *drive_path;
1101     int drive_root;
1102     LPCSTR long_name, short_name;
1103     BY_HANDLE_FILE_INFORMATION fileinfo;
1104     char dos_name[13];
1105
1106     if ((info->attr & ~(FA_UNUSED | FA_ARCHIVE | FA_RDONLY)) == FA_LABEL)
1107     {
1108         if (info->cur_pos) return 0;
1109         entry->dwFileAttributes  = FILE_ATTRIBUTE_LABEL;
1110         DOSFS_UnixTimeToFileTime( (time_t)0, &entry->ftCreationTime, 0 );
1111         DOSFS_UnixTimeToFileTime( (time_t)0, &entry->ftLastAccessTime, 0 );
1112         DOSFS_UnixTimeToFileTime( (time_t)0, &entry->ftLastWriteTime, 0 );
1113         entry->nFileSizeHigh     = 0;
1114         entry->nFileSizeLow      = 0;
1115         entry->dwReserved0       = 0;
1116         entry->dwReserved1       = 0;
1117         DOSFS_ToDosDTAFormat( DRIVE_GetLabel( info->drive ), entry->cFileName );
1118         strcpy( entry->cAlternateFileName, entry->cFileName );
1119         info->cur_pos++;
1120         return 1;
1121     }
1122
1123     drive_path = info->path + strlen(DRIVE_GetRoot( info->drive ));
1124     while ((*drive_path == '/') || (*drive_path == '\\')) drive_path++;
1125     drive_root = !*drive_path;
1126
1127     lstrcpyn32A( buffer, info->path, sizeof(buffer) - 1 );
1128     strcat( buffer, "/" );
1129     p = buffer + strlen(buffer);
1130
1131     while (DOSFS_ReadDir( info->dir, &long_name, &short_name ))
1132     {
1133         info->cur_pos++;
1134
1135         /* Don't return '.' and '..' in the root of the drive */
1136         if (drive_root && (long_name[0] == '.') &&
1137             (!long_name[1] || ((long_name[1] == '.') && !long_name[2])))
1138             continue;
1139
1140         /* Check the long mask */
1141
1142         if (info->long_mask)
1143         {
1144             if (!DOSFS_MatchLong( info->long_mask, long_name,
1145                                   flags & DRIVE_CASE_SENSITIVE )) continue;
1146         }
1147
1148         /* Check the short mask */
1149
1150         if (info->short_mask)
1151         {
1152             if (!short_name)
1153             {
1154                 DOSFS_Hash( long_name, dos_name, TRUE,
1155                             !(flags & DRIVE_CASE_SENSITIVE) );
1156                 short_name = dos_name;
1157             }
1158             if (!DOSFS_MatchShort( info->short_mask, short_name )) continue;
1159         }
1160
1161         /* Check the file attributes */
1162
1163         lstrcpyn32A( p, long_name, sizeof(buffer) - (int)(p - buffer) );
1164         if (!FILE_Stat( buffer, &fileinfo ))
1165         {
1166             WARN(dosfs, "can't stat %s\n", buffer);
1167             continue;
1168         }
1169         if (fileinfo.dwFileAttributes & ~attr) continue;
1170
1171         /* We now have a matching entry; fill the result and return */
1172
1173         entry->dwFileAttributes = fileinfo.dwFileAttributes;
1174         entry->ftCreationTime   = fileinfo.ftCreationTime;
1175         entry->ftLastAccessTime = fileinfo.ftLastAccessTime;
1176         entry->ftLastWriteTime  = fileinfo.ftLastWriteTime;
1177         entry->nFileSizeHigh    = fileinfo.nFileSizeHigh;
1178         entry->nFileSizeLow     = fileinfo.nFileSizeLow;
1179
1180         if (short_name)
1181             DOSFS_ToDosDTAFormat( short_name, entry->cAlternateFileName );
1182         else
1183             DOSFS_Hash( long_name, entry->cAlternateFileName, FALSE,
1184                         !(flags & DRIVE_CASE_SENSITIVE) );
1185
1186         lstrcpyn32A( entry->cFileName, long_name, sizeof(entry->cFileName) );
1187         if (!(flags & DRIVE_CASE_PRESERVING)) CharLower32A( entry->cFileName );
1188         TRACE(dosfs, "returning %s (%s) %02lx %ld\n",
1189                        entry->cFileName, entry->cAlternateFileName,
1190                        entry->dwFileAttributes, entry->nFileSizeLow );
1191         return 1;
1192     }
1193     return 0;  /* End of directory */
1194 }
1195
1196 /***********************************************************************
1197  *           DOSFS_FindNext
1198  *
1199  * Find the next matching file. Return the number of entries read to find
1200  * the matching one, or 0 if no more entries.
1201  * 'short_mask' is the 8.3 mask (in FCB format), 'long_mask' is the long
1202  * file name mask. Either or both can be NULL.
1203  *
1204  * NOTE: This is supposed to be only called by the int21 emulation
1205  *       routines. Thus, we should own the Win16Mutex anyway.
1206  *       Nevertheless, we explicitly enter it to ensure the static
1207  *       directory cache is protected.
1208  */
1209 int DOSFS_FindNext( const char *path, const char *short_mask,
1210                     const char *long_mask, int drive, BYTE attr,
1211                     int skip, WIN32_FIND_DATA32A *entry )
1212 {
1213     static FIND_FIRST_INFO info = { NULL };
1214     LPCSTR short_name, long_name;
1215     int count;
1216
1217     SYSLEVEL_EnterWin16Lock();
1218
1219     /* Check the cached directory */
1220     if (!(info.dir && info.path == path && info.short_mask == short_mask
1221                    && info.long_mask == long_mask && info.drive == drive
1222                    && info.attr == attr && info.cur_pos <= skip))
1223     {
1224         /* Not in the cache, open it anew */
1225         if (info.dir) DOSFS_CloseDir( info.dir );
1226
1227         info.path = (LPSTR)path;
1228         info.long_mask = (LPSTR)long_mask;
1229         info.short_mask = (LPSTR)short_mask;
1230         info.attr = attr;
1231         info.drive = drive;
1232         info.cur_pos = 0;
1233         info.dir = DOSFS_OpenDir( info.path );
1234     }
1235
1236     /* Skip to desired position */
1237     while (info.cur_pos < skip)
1238         if (info.dir && DOSFS_ReadDir( info.dir, &long_name, &short_name ))
1239             info.cur_pos++;
1240         else
1241             break;
1242
1243     if (info.dir && info.cur_pos == skip && DOSFS_FindNextEx( &info, entry ))
1244         count = info.cur_pos - skip;
1245     else
1246         count = 0;
1247
1248     if (!count)
1249     {
1250         if (info.dir) DOSFS_CloseDir( info.dir );
1251         memset( &info, '\0', sizeof(info) );
1252     }
1253
1254     SYSLEVEL_LeaveWin16Lock();
1255
1256     return count;
1257 }
1258
1259
1260
1261 /*************************************************************************
1262  *           FindFirstFile16   (KERNEL.413)
1263  */
1264 HANDLE16 WINAPI FindFirstFile16( LPCSTR path, WIN32_FIND_DATA32A *data )
1265 {
1266     DOS_FULL_NAME full_name;
1267     HGLOBAL16 handle;
1268     FIND_FIRST_INFO *info;
1269
1270     data->dwReserved0 = data->dwReserved1 = 0x0;
1271     if (!path) return 0;
1272     if (!DOSFS_GetFullName( path, FALSE, &full_name ))
1273         return INVALID_HANDLE_VALUE16;
1274     if (!(handle = GlobalAlloc16( GMEM_MOVEABLE, sizeof(FIND_FIRST_INFO) )))
1275         return INVALID_HANDLE_VALUE16;
1276     info = (FIND_FIRST_INFO *)GlobalLock16( handle );
1277     info->path = HEAP_strdupA( SystemHeap, 0, full_name.long_name );
1278     info->long_mask = strrchr( info->path, '/' );
1279     *(info->long_mask++) = '\0';
1280     info->short_mask = NULL;
1281     info->attr = 0xff;
1282     if (path[0] && (path[1] == ':')) info->drive = toupper(*path) - 'A';
1283     else info->drive = DRIVE_GetCurrentDrive();
1284     info->cur_pos = 0;
1285
1286     info->dir = DOSFS_OpenDir( info->path );
1287
1288     GlobalUnlock16( handle );
1289     if (!FindNextFile16( handle, data ))
1290     {
1291         FindClose16( handle );
1292         DOS_ERROR( ER_NoMoreFiles, EC_MediaError, SA_Abort, EL_Disk );
1293         return INVALID_HANDLE_VALUE16;
1294     }
1295     return handle;
1296 }
1297
1298
1299 /*************************************************************************
1300  *           FindFirstFile32A   (KERNEL32.123)
1301  */
1302 HANDLE32 WINAPI FindFirstFile32A( LPCSTR path, WIN32_FIND_DATA32A *data )
1303 {
1304     HANDLE32 handle = FindFirstFile16( path, data );
1305     if (handle == INVALID_HANDLE_VALUE16) return INVALID_HANDLE_VALUE32;
1306     return handle;
1307 }
1308
1309
1310 /*************************************************************************
1311  *           FindFirstFile32W   (KERNEL32.124)
1312  */
1313 HANDLE32 WINAPI FindFirstFile32W( LPCWSTR path, WIN32_FIND_DATA32W *data )
1314 {
1315     WIN32_FIND_DATA32A dataA;
1316     LPSTR pathA = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
1317     HANDLE32 handle = FindFirstFile32A( pathA, &dataA );
1318     HeapFree( GetProcessHeap(), 0, pathA );
1319     if (handle != INVALID_HANDLE_VALUE32)
1320     {
1321         data->dwFileAttributes = dataA.dwFileAttributes;
1322         data->ftCreationTime   = dataA.ftCreationTime;
1323         data->ftLastAccessTime = dataA.ftLastAccessTime;
1324         data->ftLastWriteTime  = dataA.ftLastWriteTime;
1325         data->nFileSizeHigh    = dataA.nFileSizeHigh;
1326         data->nFileSizeLow     = dataA.nFileSizeLow;
1327         lstrcpyAtoW( data->cFileName, dataA.cFileName );
1328         lstrcpyAtoW( data->cAlternateFileName, dataA.cAlternateFileName );
1329     }
1330     return handle;
1331 }
1332
1333
1334 /*************************************************************************
1335  *           FindNextFile16   (KERNEL.414)
1336  */
1337 BOOL16 WINAPI FindNextFile16( HANDLE16 handle, WIN32_FIND_DATA32A *data )
1338 {
1339     FIND_FIRST_INFO *info;
1340
1341     if (!(info = (FIND_FIRST_INFO *)GlobalLock16( handle )))
1342     {
1343         DOS_ERROR( ER_InvalidHandle, EC_ProgramError, SA_Abort, EL_Disk );
1344         return FALSE;
1345     }
1346     GlobalUnlock16( handle );
1347     if (!info->path || !info->dir)
1348     {
1349         DOS_ERROR( ER_NoMoreFiles, EC_MediaError, SA_Abort, EL_Disk );
1350         return FALSE;
1351     }
1352     if (!DOSFS_FindNextEx( info, data ))
1353     {
1354         DOSFS_CloseDir( info->dir ); info->dir = NULL;
1355         HeapFree( SystemHeap, 0, info->path );
1356         info->path = info->long_mask = NULL;
1357         DOS_ERROR( ER_NoMoreFiles, EC_MediaError, SA_Abort, EL_Disk );
1358         return FALSE;
1359     }
1360     return TRUE;
1361 }
1362
1363
1364 /*************************************************************************
1365  *           FindNextFile32A   (KERNEL32.126)
1366  */
1367 BOOL32 WINAPI FindNextFile32A( HANDLE32 handle, WIN32_FIND_DATA32A *data )
1368 {
1369     return FindNextFile16( handle, data );
1370 }
1371
1372
1373 /*************************************************************************
1374  *           FindNextFile32W   (KERNEL32.127)
1375  */
1376 BOOL32 WINAPI FindNextFile32W( HANDLE32 handle, WIN32_FIND_DATA32W *data )
1377 {
1378     WIN32_FIND_DATA32A dataA;
1379     if (!FindNextFile32A( handle, &dataA )) return FALSE;
1380     data->dwFileAttributes = dataA.dwFileAttributes;
1381     data->ftCreationTime   = dataA.ftCreationTime;
1382     data->ftLastAccessTime = dataA.ftLastAccessTime;
1383     data->ftLastWriteTime  = dataA.ftLastWriteTime;
1384     data->nFileSizeHigh    = dataA.nFileSizeHigh;
1385     data->nFileSizeLow     = dataA.nFileSizeLow;
1386     lstrcpyAtoW( data->cFileName, dataA.cFileName );
1387     lstrcpyAtoW( data->cAlternateFileName, dataA.cAlternateFileName );
1388     return TRUE;
1389 }
1390
1391
1392 /*************************************************************************
1393  *           FindClose16   (KERNEL.415)
1394  */
1395 BOOL16 WINAPI FindClose16( HANDLE16 handle )
1396 {
1397     FIND_FIRST_INFO *info;
1398
1399     if ((handle == INVALID_HANDLE_VALUE16) ||
1400         !(info = (FIND_FIRST_INFO *)GlobalLock16( handle )))
1401     {
1402         DOS_ERROR( ER_InvalidHandle, EC_ProgramError, SA_Abort, EL_Disk );
1403         return FALSE;
1404     }
1405     if (info->dir) DOSFS_CloseDir( info->dir );
1406     if (info->path) HeapFree( SystemHeap, 0, info->path );
1407     GlobalUnlock16( handle );
1408     GlobalFree16( handle );
1409     return TRUE;
1410 }
1411
1412
1413 /*************************************************************************
1414  *           FindClose32   (KERNEL32.119)
1415  */
1416 BOOL32 WINAPI FindClose32( HANDLE32 handle )
1417 {
1418     return FindClose16( (HANDLE16)handle );
1419 }
1420
1421
1422 /***********************************************************************
1423  *           DOSFS_UnixTimeToFileTime
1424  *
1425  * Convert a Unix time to FILETIME format.
1426  * The FILETIME structure is a 64-bit value representing the number of
1427  * 100-nanosecond intervals since January 1, 1601, 0:00.
1428  * 'remainder' is the nonnegative number of 100-ns intervals
1429  * corresponding to the time fraction smaller than 1 second that
1430  * couldn't be stored in the time_t value.
1431  */
1432 void DOSFS_UnixTimeToFileTime( time_t unix_time, FILETIME *filetime,
1433                                DWORD remainder )
1434 {
1435     /* NOTES:
1436
1437        CONSTANTS:
1438        The time difference between 1 January 1601, 00:00:00 and
1439        1 January 1970, 00:00:00 is 369 years, plus the leap years
1440        from 1604 to 1968, excluding 1700, 1800, 1900.
1441        This makes (1968 - 1600) / 4 - 3 = 89 leap days, and a total
1442        of 134774 days.
1443
1444        Any day in that period had 24 * 60 * 60 = 86400 seconds.
1445
1446        The time difference is 134774 * 86400 * 10000000, which can be written
1447        116444736000000000
1448        27111902 * 2^32 + 3577643008
1449        413 * 2^48 + 45534 * 2^32 + 54590 * 2^16 + 32768
1450
1451        If you find that these constants are buggy, please change them in all
1452        instances in both conversion functions.
1453
1454        VERSIONS:
1455        There are two versions, one of them uses long long variables and
1456        is presumably faster but not ISO C. The other one uses standard C
1457        data types and operations but relies on the assumption that negative
1458        numbers are stored as 2's complement (-1 is 0xffff....). If this
1459        assumption is violated, dates before 1970 will not convert correctly.
1460        This should however work on any reasonable architecture where WINE
1461        will run.
1462
1463        DETAILS:
1464
1465        Take care not to remove the casts. I have tested these functions
1466        (in both versions) for a lot of numbers. I would be interested in
1467        results on other compilers than GCC.
1468
1469        The operations have been designed to account for the possibility
1470        of 64-bit time_t in future UNICES. Even the versions without
1471        internal long long numbers will work if time_t only is 64 bit.
1472        A 32-bit shift, which was necessary for that operation, turned out
1473        not to work correctly in GCC, besides giving the warning. So I
1474        used a double 16-bit shift instead. Numbers are in the ISO version
1475        represented by three limbs, the most significant with 32 bit, the
1476        other two with 16 bit each.
1477
1478        As the modulo-operator % is not well-defined for negative numbers,
1479        negative divisors have been avoided in DOSFS_FileTimeToUnixTime.
1480
1481        There might be quicker ways to do this in C. Certainly so in
1482        assembler.
1483
1484        Claus Fischer, fischer@iue.tuwien.ac.at
1485        */
1486
1487 #if (SIZEOF_LONG_LONG >= 8)
1488 #  define USE_LONG_LONG 1
1489 #else
1490 #  define USE_LONG_LONG 0
1491 #endif
1492
1493 #if USE_LONG_LONG               /* gcc supports long long type */
1494
1495     long long int t = unix_time;
1496     t *= 10000000;
1497     t += 116444736000000000LL;
1498     t += remainder;
1499     filetime->dwLowDateTime  = (UINT32)t;
1500     filetime->dwHighDateTime = (UINT32)(t >> 32);
1501
1502 #else  /* ISO version */
1503
1504     UINT32 a0;                  /* 16 bit, low    bits */
1505     UINT32 a1;                  /* 16 bit, medium bits */
1506     UINT32 a2;                  /* 32 bit, high   bits */
1507
1508     /* Copy the unix time to a2/a1/a0 */
1509     a0 =  unix_time & 0xffff;
1510     a1 = (unix_time >> 16) & 0xffff;
1511     /* This is obsolete if unix_time is only 32 bits, but it does not hurt.
1512        Do not replace this by >> 32, it gives a compiler warning and it does
1513        not work. */
1514     a2 = (unix_time >= 0 ? (unix_time >> 16) >> 16 :
1515           ~((~unix_time >> 16) >> 16));
1516
1517     /* Multiply a by 10000000 (a = a2/a1/a0)
1518        Split the factor into 10000 * 1000 which are both less than 0xffff. */
1519     a0 *= 10000;
1520     a1 = a1 * 10000 + (a0 >> 16);
1521     a2 = a2 * 10000 + (a1 >> 16);
1522     a0 &= 0xffff;
1523     a1 &= 0xffff;
1524
1525     a0 *= 1000;
1526     a1 = a1 * 1000 + (a0 >> 16);
1527     a2 = a2 * 1000 + (a1 >> 16);
1528     a0 &= 0xffff;
1529     a1 &= 0xffff;
1530
1531     /* Add the time difference and the remainder */
1532     a0 += 32768 + (remainder & 0xffff);
1533     a1 += 54590 + (remainder >> 16   ) + (a0 >> 16);
1534     a2 += 27111902                     + (a1 >> 16);
1535     a0 &= 0xffff;
1536     a1 &= 0xffff;
1537
1538     /* Set filetime */
1539     filetime->dwLowDateTime  = (a1 << 16) + a0;
1540     filetime->dwHighDateTime = a2;
1541 #endif
1542 }
1543
1544
1545 /***********************************************************************
1546  *           DOSFS_FileTimeToUnixTime
1547  *
1548  * Convert a FILETIME format to Unix time.
1549  * If not NULL, 'remainder' contains the fractional part of the filetime,
1550  * in the range of [0..9999999] (even if time_t is negative).
1551  */
1552 time_t DOSFS_FileTimeToUnixTime( const FILETIME *filetime, DWORD *remainder )
1553 {
1554     /* Read the comment in the function DOSFS_UnixTimeToFileTime. */
1555 #if USE_LONG_LONG
1556
1557     long long int t = filetime->dwHighDateTime;
1558     t <<= 32;
1559     t += (UINT32)filetime->dwLowDateTime;
1560     t -= 116444736000000000LL;
1561     if (t < 0)
1562     {
1563         if (remainder) *remainder = 9999999 - (-t - 1) % 10000000;
1564         return -1 - ((-t - 1) / 10000000);
1565     }
1566     else
1567     {
1568         if (remainder) *remainder = t % 10000000;
1569         return t / 10000000;
1570     }
1571
1572 #else  /* ISO version */
1573
1574     UINT32 a0;                  /* 16 bit, low    bits */
1575     UINT32 a1;                  /* 16 bit, medium bits */
1576     UINT32 a2;                  /* 32 bit, high   bits */
1577     UINT32 r;                   /* remainder of division */
1578     unsigned int carry;         /* carry bit for subtraction */
1579     int negative;               /* whether a represents a negative value */
1580
1581     /* Copy the time values to a2/a1/a0 */
1582     a2 =  (UINT32)filetime->dwHighDateTime;
1583     a1 = ((UINT32)filetime->dwLowDateTime ) >> 16;
1584     a0 = ((UINT32)filetime->dwLowDateTime ) & 0xffff;
1585
1586     /* Subtract the time difference */
1587     if (a0 >= 32768           ) a0 -=             32768        , carry = 0;
1588     else                        a0 += (1 << 16) - 32768        , carry = 1;
1589
1590     if (a1 >= 54590    + carry) a1 -=             54590 + carry, carry = 0;
1591     else                        a1 += (1 << 16) - 54590 - carry, carry = 1;
1592
1593     a2 -= 27111902 + carry;
1594
1595     /* If a is negative, replace a by (-1-a) */
1596     negative = (a2 >= ((UINT32)1) << 31);
1597     if (negative)
1598     {
1599         /* Set a to -a - 1 (a is a2/a1/a0) */
1600         a0 = 0xffff - a0;
1601         a1 = 0xffff - a1;
1602         a2 = ~a2;
1603     }
1604
1605     /* Divide a by 10000000 (a = a2/a1/a0), put the rest into r.
1606        Split the divisor into 10000 * 1000 which are both less than 0xffff. */
1607     a1 += (a2 % 10000) << 16;
1608     a2 /=       10000;
1609     a0 += (a1 % 10000) << 16;
1610     a1 /=       10000;
1611     r   =  a0 % 10000;
1612     a0 /=       10000;
1613
1614     a1 += (a2 % 1000) << 16;
1615     a2 /=       1000;
1616     a0 += (a1 % 1000) << 16;
1617     a1 /=       1000;
1618     r  += (a0 % 1000) * 10000;
1619     a0 /=       1000;
1620
1621     /* If a was negative, replace a by (-1-a) and r by (9999999 - r) */
1622     if (negative)
1623     {
1624         /* Set a to -a - 1 (a is a2/a1/a0) */
1625         a0 = 0xffff - a0;
1626         a1 = 0xffff - a1;
1627         a2 = ~a2;
1628
1629         r  = 9999999 - r;
1630     }
1631
1632     if (remainder) *remainder = r;
1633
1634     /* Do not replace this by << 32, it gives a compiler warning and it does
1635        not work. */
1636     return ((((time_t)a2) << 16) << 16) + (a1 << 16) + a0;
1637 #endif
1638 }
1639
1640
1641 /***********************************************************************
1642  *           DosDateTimeToFileTime   (KERNEL32.76)
1643  */
1644 BOOL32 WINAPI DosDateTimeToFileTime( WORD fatdate, WORD fattime, LPFILETIME ft)
1645 {
1646     struct tm newtm;
1647
1648     newtm.tm_sec  = (fattime & 0x1f) * 2;
1649     newtm.tm_min  = (fattime >> 5) & 0x3f;
1650     newtm.tm_hour = (fattime >> 11);
1651     newtm.tm_mday = (fatdate & 0x1f);
1652     newtm.tm_mon  = ((fatdate >> 5) & 0x0f) - 1;
1653     newtm.tm_year = (fatdate >> 9) + 80;
1654     DOSFS_UnixTimeToFileTime( mktime( &newtm ), ft, 0 );
1655     return TRUE;
1656 }
1657
1658
1659 /***********************************************************************
1660  *           FileTimeToDosDateTime   (KERNEL32.111)
1661  */
1662 BOOL32 WINAPI FileTimeToDosDateTime( const FILETIME *ft, LPWORD fatdate,
1663                                      LPWORD fattime )
1664 {
1665     time_t unixtime = DOSFS_FileTimeToUnixTime( ft, NULL );
1666     struct tm *tm = localtime( &unixtime );
1667     if (fattime)
1668         *fattime = (tm->tm_hour << 11) + (tm->tm_min << 5) + (tm->tm_sec / 2);
1669     if (fatdate)
1670         *fatdate = ((tm->tm_year - 80) << 9) + ((tm->tm_mon + 1) << 5)
1671                    + tm->tm_mday;
1672     return TRUE;
1673 }
1674
1675
1676 /***********************************************************************
1677  *           LocalFileTimeToFileTime   (KERNEL32.373)
1678  */
1679 BOOL32 WINAPI LocalFileTimeToFileTime( const FILETIME *localft,
1680                                        LPFILETIME utcft )
1681 {
1682     struct tm *xtm;
1683     DWORD remainder;
1684
1685     /* convert from local to UTC. Perhaps not correct. FIXME */
1686     time_t unixtime = DOSFS_FileTimeToUnixTime( localft, &remainder );
1687     xtm = gmtime( &unixtime );
1688     DOSFS_UnixTimeToFileTime( mktime(xtm), utcft, remainder );
1689     return TRUE;
1690 }
1691
1692
1693 /***********************************************************************
1694  *           FileTimeToLocalFileTime   (KERNEL32.112)
1695  */
1696 BOOL32 WINAPI FileTimeToLocalFileTime( const FILETIME *utcft,
1697                                        LPFILETIME localft )
1698 {
1699     DWORD remainder;
1700     /* convert from UTC to local. Perhaps not correct. FIXME */
1701     time_t unixtime = DOSFS_FileTimeToUnixTime( utcft, &remainder );
1702 #ifdef HAVE_TIMEGM
1703     struct tm *xtm = localtime( &unixtime );
1704     time_t localtime;
1705
1706     localtime = timegm(xtm);
1707     DOSFS_UnixTimeToFileTime( localtime, localft, remainder );
1708
1709 #else
1710     struct tm *xtm,*gtm;
1711     time_t time1,time2;
1712
1713     xtm = localtime( &unixtime );
1714     gtm = gmtime( &unixtime );
1715     time1 = mktime(xtm);
1716     time2 = mktime(gtm);
1717     DOSFS_UnixTimeToFileTime( 2*time1-time2, localft, remainder );
1718 #endif
1719     return TRUE;
1720 }
1721
1722
1723 /***********************************************************************
1724  *           FileTimeToSystemTime   (KERNEL32.113)
1725  */
1726 BOOL32 WINAPI FileTimeToSystemTime( const FILETIME *ft, LPSYSTEMTIME syst )
1727 {
1728     struct tm *xtm;
1729     DWORD remainder;
1730     time_t xtime = DOSFS_FileTimeToUnixTime( ft, &remainder );
1731     xtm = gmtime(&xtime);
1732     syst->wYear         = xtm->tm_year+1900;
1733     syst->wMonth        = xtm->tm_mon + 1;
1734     syst->wDayOfWeek    = xtm->tm_wday;
1735     syst->wDay          = xtm->tm_mday;
1736     syst->wHour         = xtm->tm_hour;
1737     syst->wMinute       = xtm->tm_min;
1738     syst->wSecond       = xtm->tm_sec;
1739     syst->wMilliseconds = remainder / 10000;
1740     return TRUE;
1741 }
1742
1743 /***********************************************************************
1744  *           QueryDosDeviceA   (KERNEL32.413)
1745  *
1746  * returns array of strings terminated by \0, terminated by \0
1747  */
1748 DWORD WINAPI QueryDosDevice32A(LPCSTR devname,LPSTR target,DWORD bufsize)
1749 {
1750     LPSTR s;
1751     char  buffer[200];
1752
1753     TRACE(dosfs,"(%s,...)\n",devname?devname:"<null>");
1754     if (!devname) {
1755         /* return known MSDOS devices */
1756         lstrcpy32A(buffer,"CON COM1 COM2 LPT1 NUL ");
1757         while ((s=strchr(buffer,' ')))
1758                 *s='\0';
1759
1760         lstrcpyn32A(target,buffer,bufsize);
1761         return strlen(buffer);
1762     }
1763     lstrcpy32A(buffer,"\\DEV\\");
1764     lstrcat32A(buffer,devname);
1765     if ((s=strchr(buffer,':'))) *s='\0';
1766     lstrcpyn32A(target,buffer,bufsize);
1767     return strlen(buffer);
1768 }
1769
1770
1771 /***********************************************************************
1772  *           QueryDosDeviceW   (KERNEL32.414)
1773  *
1774  * returns array of strings terminated by \0, terminated by \0
1775  */
1776 DWORD WINAPI QueryDosDevice32W(LPCWSTR devname,LPWSTR target,DWORD bufsize)
1777 {
1778     LPSTR devnameA = devname?HEAP_strdupWtoA(GetProcessHeap(),0,devname):NULL;
1779     LPSTR targetA = (LPSTR)HEAP_xalloc(GetProcessHeap(),0,bufsize);
1780     DWORD ret = QueryDosDevice32A(devnameA,targetA,bufsize);
1781
1782     lstrcpynAtoW(target,targetA,bufsize);
1783     if (devnameA) HeapFree(GetProcessHeap(),0,devnameA);
1784     if (targetA) HeapFree(GetProcessHeap(),0,targetA);
1785     return ret;
1786 }
1787
1788
1789 /***********************************************************************
1790  *           SystemTimeToFileTime   (KERNEL32.526)
1791  */
1792 BOOL32 WINAPI SystemTimeToFileTime( const SYSTEMTIME *syst, LPFILETIME ft )
1793 {
1794 #ifdef HAVE_TIMEGM
1795     struct tm xtm;
1796     time_t utctime;
1797 #else
1798     struct tm xtm,*local_tm,*utc_tm;
1799     time_t localtim,utctime;
1800 #endif
1801
1802     xtm.tm_year = syst->wYear-1900;
1803     xtm.tm_mon  = syst->wMonth - 1;
1804     xtm.tm_wday = syst->wDayOfWeek;
1805     xtm.tm_mday = syst->wDay;
1806     xtm.tm_hour = syst->wHour;
1807     xtm.tm_min  = syst->wMinute;
1808     xtm.tm_sec  = syst->wSecond; /* this is UTC */
1809     xtm.tm_isdst = -1;
1810 #ifdef HAVE_TIMEGM
1811     utctime = timegm(&xtm);
1812     DOSFS_UnixTimeToFileTime( utctime, ft,
1813                               syst->wMilliseconds * 10000 );
1814 #else
1815     localtim = mktime(&xtm);    /* now we've got local time */
1816     local_tm = localtime(&localtim);
1817     utc_tm = gmtime(&localtim);
1818     utctime = mktime(utc_tm);
1819     DOSFS_UnixTimeToFileTime( 2*localtim -utctime, ft,
1820                               syst->wMilliseconds * 10000 );
1821 #endif
1822     return TRUE;
1823 }
1824
1825 BOOL32 WINAPI DefineDosDevice32A(DWORD flags,LPCSTR devname,LPCSTR targetpath) {
1826         FIXME(dosfs,"(0x%08lx,%s,%s),stub!\n",flags,devname,targetpath);
1827         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1828         return FALSE;
1829 }