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