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 #ifdef HAVE_SYS_ERRNO_H
  14 #include <sys/errno.h>
  15 #endif
  16 #include <fcntl.h>
  17 #include <string.h>
  18 #include <stdlib.h>
  19 #include <sys/stat.h>
  20 #include <sys/ioctl.h>
  21 #include <time.h>
  22 #include <unistd.h>
  23
  24 #include "windef.h"
  25 #include "ntddk.h"
  26 #include "winnls.h"
  27 #include "wine/winbase16.h"
  28 #include "wine/unicode.h"
  29 #include "winerror.h"
  30 #include "drive.h"
  31 #include "file.h"
  32 #include "heap.h"
  33 #include "msdos.h"
  34 #include "server.h"
  35 #include "options.h"
  36 #include "debugtools.h"
  37
  38 DEFAULT_DEBUG_CHANNEL(dosfs);
  39 DECLARE_DEBUG_CHANNEL(file);
  40
  41 /* Define the VFAT ioctl to get both short and long file names */
  42 /* FIXME: is it possible to get this to work on other systems? */
  43 #ifdef linux
  44 /* We want the real kernel dirent structure, not the libc one */
  45 typedef struct
  46 {
  47     long d_ino;
  48     long d_off;
  49     unsigned short d_reclen;
  50     char d_name[256];
  51 } KERNEL_DIRENT;
  52
  53 #define VFAT_IOCTL_READDIR_BOTH  _IOR('r', 1, KERNEL_DIRENT [2] )
  54
  55 #else   /* linux */
  56 #undef VFAT_IOCTL_READDIR_BOTH  /* just in case... */
  57 #endif  /* linux */
  58
  59 /* Chars we don't want to see in DOS file names */
  60 #define INVALID_DOS_CHARS  "*?<>|\"+=,;[] \345"
  61
  62 static const DOS_DEVICE DOSFS_Devices[] =
  63 /* name, device flags (see Int 21/AX=0x4400) */
  64 {
  65     { "CON",            0xc0d3 },
  66     { "PRN",            0xa0c0 },
  67     { "NUL",            0x80c4 },
  68     { "AUX",            0x80c0 },
  69     { "LPT1",           0xa0c0 },
  70     { "LPT2",           0xa0c0 },
  71     { "LPT3",           0xa0c0 },
  72     { "LPT4",           0xc0d3 },
  73     { "COM1",           0x80c0 },
  74     { "COM2",           0x80c0 },
  75     { "COM3",           0x80c0 },
  76     { "COM4",           0x80c0 },
  77     { "SCSIMGR$",       0xc0c0 },
  78     { "HPSCAN",         0xc0c0 }
  79 };
  80
  81 #define GET_DRIVE(path) \
  82     (((path)[1] == ':') ? FILE_toupper((path)[0]) - 'A' : DOSFS_CurDrive)
  83
  84 /* Directory info for DOSFS_ReadDir */
  85 typedef struct
  86 {
  87     DIR           *dir;
  88 #ifdef VFAT_IOCTL_READDIR_BOTH
  89     int            fd;
  90     char           short_name[12];
  91     KERNEL_DIRENT  dirent[2];
  92 #endif
  93 } DOS_DIR;
  94
  95 /* Info structure for FindFirstFile handle */
  96 typedef struct
  97 {
  98     LPSTR path;
  99     LPSTR long_mask;
 100     LPSTR short_mask;
 101     BYTE  attr;
 102     int   drive;
 103     int   cur_pos;
 104     DOS_DIR *dir;
 105 } FIND_FIRST_INFO;
 106
 107
 108
 109 /***********************************************************************
 110  *           DOSFS_ValidDOSName
 111  *
 112  * Return 1 if Unix file 'name' is also a valid MS-DOS name
 113  * (i.e. contains only valid DOS chars, lower-case only, fits in 8.3 format).
 114  * File name can be terminated by '\0', '\\' or '/'.
 115  */
 116 static int DOSFS_ValidDOSName( const char *name, int ignore_case )
 117 {
 118     static const char invalid_chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" INVALID_DOS_CHARS;
 119     const char *p = name;
 120     const char *invalid = ignore_case ? (invalid_chars + 26) : invalid_chars;
 121     int len = 0;
 122
 123     if (*p == '.')
 124     {
 125         /* Check for "." and ".." */
 126         p++;
 127         if (*p == '.') p++;
 128         /* All other names beginning with '.' are invalid */
 129         return (IS_END_OF_NAME(*p));
 130     }
 131     while (!IS_END_OF_NAME(*p))
 132     {
 133         if (strchr( invalid, *p )) return 0;  /* Invalid char */
 134         if (*p == '.') break;  /* Start of the extension */
 135         if (++len > 8) return 0;  /* Name too long */
 136         p++;
 137     }
 138     if (*p != '.') return 1;  /* End of name */
 139     p++;
 140     if (IS_END_OF_NAME(*p)) return 0;  /* Empty extension not allowed */
 141     len = 0;
 142     while (!IS_END_OF_NAME(*p))
 143     {
 144         if (strchr( invalid, *p )) return 0;  /* Invalid char */
 145         if (*p == '.') return 0;  /* Second extension not allowed */
 146         if (++len > 3) return 0;  /* Extension too long */
 147         p++;
 148     }
 149     return 1;
 150 }
 151
 152
 153 /***********************************************************************
 154  *           DOSFS_ToDosFCBFormat
 155  *
 156  * Convert a file name to DOS FCB format (8+3 chars, padded with blanks),
 157  * expanding wild cards and converting to upper-case in the process.
 158  * File name can be terminated by '\0', '\\' or '/'.
 159  * Return FALSE if the name is not a valid DOS name.
 160  * 'buffer' must be at least 12 characters long.
 161  */
 162 BOOL DOSFS_ToDosFCBFormat( LPCSTR name, LPSTR buffer )
 163 {
 164     static const char invalid_chars[] = INVALID_DOS_CHARS;
 165     const char *p = name;
 166     int i;
 167
 168     /* Check for "." and ".." */
 169     if (*p == '.')
 170     {
 171         p++;
 172         strcpy( buffer, ".          " );
 173         if (*p == '.')
 174         {
 175             buffer[1] = '.';
 176             p++;
 177         }
 178         return (!*p || (*p == '/') || (*p == '\\'));
 179     }
 180
 181     for (i = 0; i < 8; i++)
 182     {
 183         switch(*p)
 184         {
 185         case '\0':
 186         case '\\':
 187         case '/':
 188         case '.':
 189             buffer[i] = ' ';
 190             break;
 191         case '?':
 192             p++;
 193             /* fall through */
 194         case '*':
 195             buffer[i] = '?';
 196             break;
 197         default:
 198             if (strchr( invalid_chars, *p )) return FALSE;
 199             buffer[i] = FILE_toupper(*p);
 200             p++;
 201             break;
 202         }
 203     }
 204
 205     if (*p == '*')
 206     {
 207         /* Skip all chars after wildcard up to first dot */
 208         while (*p && (*p != '/') && (*p != '\\') && (*p != '.')) p++;
 209     }
 210     else
 211     {
 212         /* Check if name too long */
 213         if (*p && (*p != '/') && (*p != '\\') && (*p != '.')) return FALSE;
 214     }
 215     if (*p == '.') p++;  /* Skip dot */
 216
 217     for (i = 8; i < 11; i++)
 218     {
 219         switch(*p)
 220         {
 221         case '\0':
 222         case '\\':
 223         case '/':
 224             buffer[i] = ' ';
 225             break;
 226         case '.':
 227             return FALSE;  /* Second extension not allowed */
 228         case '?':
 229             p++;
 230             /* fall through */
 231         case '*':
 232             buffer[i] = '?';
 233             break;
 234         default:
 235             if (strchr( invalid_chars, *p )) return FALSE;
 236             buffer[i] = FILE_toupper(*p);
 237             p++;
 238             break;
 239         }
 240     }
 241     buffer[11] = '\0';
 242
 243     /* at most 3 character of the extension are processed
 244      * is something behind this ?
 245      */
 246     while (*p == '*' || *p == ' ') p++; /* skip wildcards and spaces */
 247     return IS_END_OF_NAME(*p);
 248 }
 249
 250
 251 /***********************************************************************
 252  *           DOSFS_ToDosDTAFormat
 253  *
 254  * Convert a file name from FCB to DTA format (name.ext, null-terminated)
 255  * converting to upper-case in the process.
 256  * File name can be terminated by '\0', '\\' or '/'.
 257  * 'buffer' must be at least 13 characters long.
 258  */
 259 static void DOSFS_ToDosDTAFormat( LPCSTR name, LPSTR buffer )
 260 {
 261     char *p;
 262
 263     memcpy( buffer, name, 8 );
 264     for (p = buffer + 8; (p > buffer) && (p[-1] == ' '); p--);
 265     *p++ = '.';
 266     memcpy( p, name + 8, 3 );
 267     for (p += 3; p[-1] == ' '; p--);
 268     if (p[-1] == '.') p--;
 269     *p = '\0';
 270 }
 271
 272
 273 /***********************************************************************
 274  *           DOSFS_MatchShort
 275  *
 276  * Check a DOS file name against a mask (both in FCB format).
 277  */
 278 static int DOSFS_MatchShort( const char *mask, const char *name )
 279 {
 280     int i;
 281     for (i = 11; i > 0; i--, mask++, name++)
 282         if ((*mask != '?') && (*mask != *name)) return 0;
 283     return 1;
 284 }
 285
 286
 287 /***********************************************************************
 288  *           DOSFS_MatchLong
 289  *
 290  * Check a long file name against a mask.
 291  *
 292  * Tests (done in W95 DOS shell - case insensitive):
 293  * *.txt                        test1.test.txt                          *
 294  * *st1*                        test1.txt                               *
 295  * *.t??????.t*                 test1.ta.tornado.txt                    *
 296  * *tornado*                    test1.ta.tornado.txt                    *
 297  * t*t                          test1.ta.tornado.txt                    *
 298  * ?est*                        test1.txt                               *
 299  * ?est???                      test1.txt                               -
 300  * *test1.txt*                  test1.txt                               *
 301  * h?l?o*t.dat                  hellothisisatest.dat                    *
 302  */
 303 static int DOSFS_MatchLong( const char *mask, const char *name,
 304                             int case_sensitive )
 305 {
 306     const char *lastjoker = NULL;
 307     const char *next_to_retry = NULL;
 308
 309     if (!strcmp( mask, "*.*" )) return 1;
 310     while (*name && *mask)
 311     {
 312         if (*mask == '*')
 313         {
 314             mask++;
 315             while (*mask == '*') mask++;  /* Skip consecutive '*' */
 316             lastjoker = mask;
 317             if (!*mask) return 1; /* end of mask is all '*', so match */
 318
 319             /* skip to the next match after the joker(s) */
 320             if (case_sensitive) while (*name && (*name != *mask)) name++;
 321             else while (*name && (FILE_toupper(*name) != FILE_toupper(*mask))) name++;
 322
 323             if (!*name) break;
 324             next_to_retry = name;
 325         }
 326         else if (*mask != '?')
 327         {
 328             int mismatch = 0;
 329             if (case_sensitive)
 330             {
 331                 if (*mask != *name) mismatch = 1;
 332             }
 333             else
 334             {
 335                 if (FILE_toupper(*mask) != FILE_toupper(*name)) mismatch = 1;
 336             }
 337             if (!mismatch)
 338             {
 339                 mask++;
 340                 name++;
 341                 if (*mask == '\0')
 342                 {
 343                     if (*name == '\0')
 344                         return 1;
 345                     if (lastjoker)
 346                         mask = lastjoker;
 347                 }
 348             }
 349             else /* mismatch ! */
 350             {
 351                 if (lastjoker) /* we had an '*', so we can try unlimitedly */
 352                 {
 353                     mask = lastjoker;
 354
 355                     /* this scan sequence was a mismatch, so restart
 356                      * 1 char after the first char we checked last time */
 357                     next_to_retry++;
 358                     name = next_to_retry;
 359                 }
 360                 else
 361                     return 0; /* bad luck */
 362             }
 363         }
 364         else /* '?' */
 365         {
 366             mask++;
 367             name++;
 368         }
 369     }
 370     while ((*mask == '.') || (*mask == '*'))
 371         mask++;  /* Ignore trailing '.' or '*' in mask */
 372     return (!*name && !*mask);
 373 }
 374
 375
 376 /***********************************************************************
 377  *           DOSFS_OpenDir
 378  */
 379 static DOS_DIR *DOSFS_OpenDir( LPCSTR path )
 380 {
 381     DOS_DIR *dir = HeapAlloc( GetProcessHeap(), 0, sizeof(*dir) );
 382     if (!dir)
 383     {
 384         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 385         return NULL;
 386     }
 387
 388     /* Treat empty path as root directory. This simplifies path split into
 389        directory and mask in several other places */
 390     if (!*path) path = "/";
 391
 392 #ifdef VFAT_IOCTL_READDIR_BOTH
 393
 394     /* Check if the VFAT ioctl is supported on this directory */
 395
 396     if ((dir->fd = open( path, O_RDONLY )) != -1)
 397     {
 398         if (ioctl( dir->fd, VFAT_IOCTL_READDIR_BOTH, (long)dir->dirent ) == -1)
 399         {
 400             close( dir->fd );
 401             dir->fd = -1;
 402         }
 403         else
 404         {
 405             /* Set the file pointer back at the start of the directory */
 406             lseek( dir->fd, 0, SEEK_SET );
 407             dir->dir = NULL;
 408             return dir;
 409         }
 410     }
 411 #endif  /* VFAT_IOCTL_READDIR_BOTH */
 412
 413     /* Now use the standard opendir/readdir interface */
 414
 415     if (!(dir->dir = opendir( path )))
 416     {
 417         HeapFree( GetProcessHeap(), 0, dir );
 418         return NULL;
 419     }
 420     return dir;
 421 }
 422
 423
 424 /***********************************************************************
 425  *           DOSFS_CloseDir
 426  */
 427 static void DOSFS_CloseDir( DOS_DIR *dir )
 428 {
 429 #ifdef VFAT_IOCTL_READDIR_BOTH
 430     if (dir->fd != -1) close( dir->fd );
 431 #endif  /* VFAT_IOCTL_READDIR_BOTH */
 432     if (dir->dir) closedir( dir->dir );
 433     HeapFree( GetProcessHeap(), 0, dir );
 434 }
 435
 436
 437 /***********************************************************************
 438  *           DOSFS_ReadDir
 439  */
 440 static BOOL DOSFS_ReadDir( DOS_DIR *dir, LPCSTR *long_name,
 441                              LPCSTR *short_name )
 442 {
 443     struct dirent *dirent;
 444
 445 #ifdef VFAT_IOCTL_READDIR_BOTH
 446     if (dir->fd != -1)
 447     {
 448         if (ioctl( dir->fd, VFAT_IOCTL_READDIR_BOTH, (long)dir->dirent ) != -1) {
 449             if (!dir->dirent[0].d_reclen) return FALSE;
 450             if (!DOSFS_ToDosFCBFormat( dir->dirent[0].d_name, dir->short_name ))
 451                 dir->short_name[0] = '\0';
 452             *short_name = dir->short_name;
 453             if (dir->dirent[1].d_name[0]) *long_name = dir->dirent[1].d_name;
 454             else *long_name = dir->dirent[0].d_name;
 455             return TRUE;
 456         }
 457     }
 458 #endif  /* VFAT_IOCTL_READDIR_BOTH */
 459
 460     if (!(dirent = readdir( dir->dir ))) return FALSE;
 461     *long_name  = dirent->d_name;
 462     *short_name = NULL;
 463     return TRUE;
 464 }
 465
 466
 467 /***********************************************************************
 468  *           DOSFS_Hash
 469  *
 470  * Transform a Unix file name into a hashed DOS name. If the name is a valid
 471  * DOS name, it is converted to upper-case; otherwise it is replaced by a
 472  * hashed version that fits in 8.3 format.
 473  * File name can be terminated by '\0', '\\' or '/'.
 474  * 'buffer' must be at least 13 characters long.
 475  */
 476 static void DOSFS_Hash( LPCSTR name, LPSTR buffer, BOOL dir_format,
 477                         BOOL ignore_case )
 478 {
 479     static const char invalid_chars[] = INVALID_DOS_CHARS "~.";
 480     static const char hash_chars[32] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ012345";
 481
 482     const char *p, *ext;
 483     char *dst;
 484     unsigned short hash;
 485     int i;
 486
 487     if (dir_format) strcpy( buffer, "           " );
 488
 489     if (DOSFS_ValidDOSName( name, ignore_case ))
 490     {
 491         /* Check for '.' and '..' */
 492         if (*name == '.')
 493         {
 494             buffer[0] = '.';
 495             if (!dir_format) buffer[1] = buffer[2] = '\0';
 496             if (name[1] == '.') buffer[1] = '.';
 497             return;
 498         }
 499
 500         /* Simply copy the name, converting to uppercase */
 501
 502         for (dst = buffer; !IS_END_OF_NAME(*name) && (*name != '.'); name++)
 503             *dst++ = FILE_toupper(*name);
 504         if (*name == '.')
 505         {
 506             if (dir_format) dst = buffer + 8;
 507             else *dst++ = '.';
 508             for (name++; !IS_END_OF_NAME(*name); name++)
 509                 *dst++ = FILE_toupper(*name);
 510         }
 511         if (!dir_format) *dst = '\0';
 512         return;
 513     }
 514
 515     /* Compute the hash code of the file name */
 516     /* If you know something about hash functions, feel free to */
 517     /* insert a better algorithm here... */
 518     if (ignore_case)
 519     {
 520         for (p = name, hash = 0xbeef; !IS_END_OF_NAME(p[1]); p++)
 521             hash = (hash<<3) ^ (hash>>5) ^ FILE_tolower(*p) ^ (FILE_tolower(p[1]) << 8);
 522         hash = (hash<<3) ^ (hash>>5) ^ FILE_tolower(*p); /* Last character*/
 523     }
 524     else
 525     {
 526         for (p = name, hash = 0xbeef; !IS_END_OF_NAME(p[1]); p++)
 527             hash = (hash << 3) ^ (hash >> 5) ^ *p ^ (p[1] << 8);
 528         hash = (hash << 3) ^ (hash >> 5) ^ *p;  /* Last character */
 529     }
 530
 531     /* Find last dot for start of the extension */
 532     for (p = name+1, ext = NULL; !IS_END_OF_NAME(*p); p++)
 533         if (*p == '.') ext = p;
 534     if (ext && IS_END_OF_NAME(ext[1]))
 535         ext = NULL;  /* Empty extension ignored */
 536
 537     /* Copy first 4 chars, replacing invalid chars with '_' */
 538     for (i = 4, p = name, dst = buffer; i > 0; i--, p++)
 539     {
 540         if (IS_END_OF_NAME(*p) || (p == ext)) break;
 541         *dst++ = strchr( invalid_chars, *p ) ? '_' : FILE_toupper(*p);
 542     }
 543     /* Pad to 5 chars with '~' */
 544     while (i-- >= 0) *dst++ = '~';
 545
 546     /* Insert hash code converted to 3 ASCII chars */
 547     *dst++ = hash_chars[(hash >> 10) & 0x1f];
 548     *dst++ = hash_chars[(hash >> 5) & 0x1f];
 549     *dst++ = hash_chars[hash & 0x1f];
 550
 551     /* Copy the first 3 chars of the extension (if any) */
 552     if (ext)
 553     {
 554         if (!dir_format) *dst++ = '.';
 555         for (i = 3, ext++; (i > 0) && !IS_END_OF_NAME(*ext); i--, ext++)
 556             *dst++ = strchr( invalid_chars, *ext ) ? '_' : FILE_toupper(*ext);
 557     }
 558     if (!dir_format) *dst = '\0';
 559 }
 560
 561
 562 /***********************************************************************
 563  *           DOSFS_FindUnixName
 564  *
 565  * Find the Unix file name in a given directory that corresponds to
 566  * a file name (either in Unix or DOS format).
 567  * File name can be terminated by '\0', '\\' or '/'.
 568  * Return TRUE if OK, FALSE if no file name matches.
 569  *
 570  * 'long_buf' must be at least 'long_len' characters long. If the long name
 571  * turns out to be larger than that, the function returns FALSE.
 572  * 'short_buf' must be at least 13 characters long.
 573  */
 574 BOOL DOSFS_FindUnixName( LPCSTR path, LPCSTR name, LPSTR long_buf,
 575                            INT long_len, LPSTR short_buf, BOOL ignore_case)
 576 {
 577     DOS_DIR *dir;
 578     LPCSTR long_name, short_name;
 579     char dos_name[12], tmp_buf[13];
 580     BOOL ret;
 581
 582     const char *p = strchr( name, '/' );
 583     int len = p ? (int)(p - name) : strlen(name);
 584     if ((p = strchr( name, '\\' ))) len = min( (int)(p - name), len );
 585     /* Ignore trailing dots and spaces */
 586     while (len > 1 && (name[len-1] == '.' || name[len-1] == ' ')) len--;
 587     if (long_len < len + 1) return FALSE;
 588
 589     TRACE("%s,%s\n", path, name );
 590
 591     if (!DOSFS_ToDosFCBFormat( name, dos_name )) dos_name[0] = '\0';
 592
 593     if (!(dir = DOSFS_OpenDir( path )))
 594     {
 595         WARN("(%s,%s): can't open dir: %s\n",
 596                        path, name, strerror(errno) );
 597         return FALSE;
 598     }
 599
 600     while ((ret = DOSFS_ReadDir( dir, &long_name, &short_name )))
 601     {
 602         /* Check against Unix name */
 603         if (len == strlen(long_name))
 604         {
 605             if (!ignore_case)
 606             {
 607                 if (!strncmp( long_name, name, len )) break;
 608             }
 609             else
 610             {
 611                 if (!FILE_strncasecmp( long_name, name, len )) break;
 612             }
 613         }
 614         if (dos_name[0])
 615         {
 616             /* Check against hashed DOS name */
 617             if (!short_name)
 618             {
 619                 DOSFS_Hash( long_name, tmp_buf, TRUE, ignore_case );
 620                 short_name = tmp_buf;
 621             }
 622             if (!strcmp( dos_name, short_name )) break;
 623         }
 624     }
 625     if (ret)
 626     {
 627         if (long_buf) strcpy( long_buf, long_name );
 628         if (short_buf)
 629         {
 630             if (short_name)
 631                 DOSFS_ToDosDTAFormat( short_name, short_buf );
 632             else
 633                 DOSFS_Hash( long_name, short_buf, FALSE, ignore_case );
 634         }
 635         TRACE("(%s,%s) -> %s (%s)\n",
 636               path, name, long_name, short_buf ? short_buf : "***");
 637     }
 638     else
 639         WARN("'%s' not found in '%s'\n", name, path);
 640     DOSFS_CloseDir( dir );
 641     return ret;
 642 }
 643
 644
 645 /***********************************************************************
 646  *           DOSFS_GetDevice
 647  *
 648  * Check if a DOS file name represents a DOS device and return the device.
 649  */
 650 const DOS_DEVICE *DOSFS_GetDevice( const char *name )
 651 {
 652     int i;
 653     const char *p;
 654
 655     if (!name) return NULL; /* if FILE_DupUnixHandle was used */
 656     if (name[0] && (name[1] == ':')) name += 2;
 657     if ((p = strrchr( name, '/' ))) name = p + 1;
 658     if ((p = strrchr( name, '\\' ))) name = p + 1;
 659     for (i = 0; i < sizeof(DOSFS_Devices)/sizeof(DOSFS_Devices[0]); i++)
 660     {
 661         const char *dev = DOSFS_Devices[i].name;
 662         if (!FILE_strncasecmp( dev, name, strlen(dev) ))
 663         {
 664             p = name + strlen( dev );
 665             if (!*p || (*p == '.') || (*p == ':')) return &DOSFS_Devices[i];
 666         }
 667     }
 668     return NULL;
 669 }
 670
 671
 672 /***********************************************************************
 673  *           DOSFS_GetDeviceByHandle
 674  */
 675 const DOS_DEVICE *DOSFS_GetDeviceByHandle( HFILE hFile )
 676 {
 677     const DOS_DEVICE *ret = NULL;
 678     SERVER_START_REQ
 679     {
 680         struct get_file_info_request *req = server_alloc_req( sizeof(*req), 0 );
 681
 682         req->handle = hFile;
 683         if (!server_call( REQ_GET_FILE_INFO ) && (req->type == FILE_TYPE_UNKNOWN))
 684         {
 685             if ((req->attr >= 0) &&
 686                 (req->attr < sizeof(DOSFS_Devices)/sizeof(DOSFS_Devices[0])))
 687                 ret = &DOSFS_Devices[req->attr];
 688         }
 689     }
 690     SERVER_END_REQ;
 691     return ret;
 692 }
 693
 694
 695 /**************************************************************************
 696  *         DOSFS_CreateCommPort
 697  */
 698 static HANDLE DOSFS_CreateCommPort(LPCSTR name, DWORD access)
 699 {
 700     HANDLE ret;
 701     char devname[40];
 702
 703     TRACE("%s %lx\n", name, access);
 704
 705     PROFILE_GetWineIniString("serialports",name,"",devname,sizeof devname);
 706     if(!devname[0])
 707         return 0;
 708
 709     TRACE("opening %s as %s\n", devname, name);
 710
 711     SERVER_START_REQ
 712     {
 713         size_t len = strlen(devname);
 714         struct create_serial_request *req = server_alloc_req( sizeof(*req), len );
 715
 716         req->access  = access;
 717         req->inherit = 0;  /*FIXME*/
 718         req->sharing = FILE_SHARE_READ|FILE_SHARE_WRITE;
 719         memcpy( server_data_ptr(req), devname, len );
 720         SetLastError(0);
 721         server_call( REQ_CREATE_SERIAL );
 722         ret = req->handle;
 723     }
 724     SERVER_END_REQ;
 725
 726     TRACE("return %08X\n", ret );
 727     return ret;
 728 }
 729
 730 /***********************************************************************
 731  *           DOSFS_OpenDevice
 732  *
 733  * Open a DOS device. This might not map 1:1 into the UNIX device concept.
 734  * Returns 0 on failure.
 735  */
 736 HANDLE DOSFS_OpenDevice( const char *name, DWORD access )
 737 {
 738     int i;
 739     const char *p;
 740     HANDLE handle;
 741
 742     if (name[0] && (name[1] == ':')) name += 2;
 743     if ((p = strrchr( name, '/' ))) name = p + 1;
 744     if ((p = strrchr( name, '\\' ))) name = p + 1;
 745     for (i = 0; i < sizeof(DOSFS_Devices)/sizeof(DOSFS_Devices[0]); i++)
 746     {
 747         const char *dev = DOSFS_Devices[i].name;
 748         if (!FILE_strncasecmp( dev, name, strlen(dev) ))
 749         {
 750             p = name + strlen( dev );
 751             if (!*p || (*p == '.') || (*p == ':')) {
 752                 /* got it */
 753                 if (!strcmp(DOSFS_Devices[i].name,"NUL"))
 754                     return FILE_CreateFile( "/dev/null", access,
 755                                             FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
 756                                             OPEN_EXISTING, 0, 0, TRUE );
 757                 if (!strcmp(DOSFS_Devices[i].name,"CON")) {
 758                         HANDLE to_dup;
 759                         switch (access & (GENERIC_READ|GENERIC_WRITE)) {
 760                         case GENERIC_READ:
 761                                 to_dup = GetStdHandle( STD_INPUT_HANDLE );
 762                                 break;
 763                         case GENERIC_WRITE:
 764                                 to_dup = GetStdHandle( STD_OUTPUT_HANDLE );
 765                                 break;
 766                         default:
 767                                 FIXME("can't open CON read/write\n");
 768                                 return 0;
 769                         }
 770                         if (!DuplicateHandle( GetCurrentProcess(), to_dup, GetCurrentProcess(),
 771                                               &handle, 0, FALSE, DUPLICATE_SAME_ACCESS ))
 772                             handle = 0;
 773                         return handle;
 774                 }
 775                 if (!strcmp(DOSFS_Devices[i].name,"SCSIMGR$") ||
 776                     !strcmp(DOSFS_Devices[i].name,"HPSCAN"))
 777                 {
 778                     return FILE_CreateDevice( i, access, NULL );
 779                 }
 780
 781                 if( (handle=DOSFS_CreateCommPort(DOSFS_Devices[i].name,access)) )
 782                     return handle;
 783
 784                 FIXME("device open %s not supported (yet)\n",DOSFS_Devices[i].name);
 785                 return 0;
 786             }
 787         }
 788     }
 789     return 0;
 790 }
 791
 792
 793 /***********************************************************************
 794  *           DOSFS_GetPathDrive
 795  *
 796  * Get the drive specified by a given path name (DOS or Unix format).
 797  */
 798 static int DOSFS_GetPathDrive( const char **name )
 799 {
 800     int drive;
 801     const char *p = *name;
 802
 803     if (*p && (p[1] == ':'))
 804     {
 805         drive = FILE_toupper(*p) - 'A';
 806         *name += 2;
 807     }
 808     else if (*p == '/') /* Absolute Unix path? */
 809     {
 810         if ((drive = DRIVE_FindDriveRoot( name )) == -1)
 811         {
 812             MESSAGE("Warning: %s not accessible from a DOS drive\n", *name );
 813             /* Assume it really was a DOS name */
 814             drive = DRIVE_GetCurrentDrive();
 815         }
 816     }
 817     else drive = DRIVE_GetCurrentDrive();
 818
 819     if (!DRIVE_IsValid(drive))
 820     {
 821         SetLastError( ERROR_INVALID_DRIVE );
 822         return -1;
 823     }
 824     return drive;
 825 }
 826
 827
 828 /***********************************************************************
 829  *           DOSFS_GetFullName
 830  *
 831  * Convert a file name (DOS or mixed DOS/Unix format) to a valid
 832  * Unix name / short DOS name pair.
 833  * Return FALSE if one of the path components does not exist. The last path
 834  * component is only checked if 'check_last' is non-zero.
 835  * The buffers pointed to by 'long_buf' and 'short_buf' must be
 836  * at least MAX_PATHNAME_LEN long.
 837  */
 838 BOOL DOSFS_GetFullName( LPCSTR name, BOOL check_last, DOS_FULL_NAME *full )
 839 {
 840     BOOL found;
 841     UINT flags;
 842     char *p_l, *p_s, *root;
 843
 844     TRACE("%s (last=%d)\n", name, check_last );
 845
 846     if ((!*name) || (*name=='\n'))
 847     { /* error code for Win98 */
 848         SetLastError(ERROR_BAD_PATHNAME);
 849         return FALSE;
 850     }
 851
 852     if ((full->drive = DOSFS_GetPathDrive( &name )) == -1) return FALSE;
 853     flags = DRIVE_GetFlags( full->drive );
 854
 855     lstrcpynA( full->long_name, DRIVE_GetRoot( full->drive ),
 856                  sizeof(full->long_name) );
 857     if (full->long_name[1]) root = full->long_name + strlen(full->long_name);
 858     else root = full->long_name;  /* root directory */
 859
 860     strcpy( full->short_name, "A:\\" );
 861     full->short_name[0] += full->drive;
 862
 863     if ((*name == '\\') || (*name == '/'))  /* Absolute path */
 864     {
 865         while ((*name == '\\') || (*name == '/')) name++;
 866     }
 867     else  /* Relative path */
 868     {
 869         lstrcpynA( root + 1, DRIVE_GetUnixCwd( full->drive ),
 870                      sizeof(full->long_name) - (root - full->long_name) - 1 );
 871         if (root[1]) *root = '/';
 872         lstrcpynA( full->short_name + 3, DRIVE_GetDosCwd( full->drive ),
 873                      sizeof(full->short_name) - 3 );
 874     }
 875
 876     p_l = full->long_name[1] ? full->long_name + strlen(full->long_name)
 877                              : full->long_name;
 878     p_s = full->short_name[3] ? full->short_name + strlen(full->short_name)
 879                               : full->short_name + 2;
 880     found = TRUE;
 881
 882     while (*name && found)
 883     {
 884         /* Check for '.' and '..' */
 885
 886         if (*name == '.')
 887         {
 888             if (IS_END_OF_NAME(name[1]))
 889             {
 890                 name++;
 891                 while ((*name == '\\') || (*name == '/')) name++;
 892                 continue;
 893             }
 894             else if ((name[1] == '.') && IS_END_OF_NAME(name[2]))
 895             {
 896                 name += 2;
 897                 while ((*name == '\\') || (*name == '/')) name++;
 898                 while ((p_l > root) && (*p_l != '/')) p_l--;
 899                 while ((p_s > full->short_name + 2) && (*p_s != '\\')) p_s--;
 900                 *p_l = *p_s = '\0';  /* Remove trailing separator */
 901                 continue;
 902             }
 903         }
 904
 905         /* Make sure buffers are large enough */
 906
 907         if ((p_s >= full->short_name + sizeof(full->short_name) - 14) ||
 908             (p_l >= full->long_name + sizeof(full->long_name) - 1))
 909         {
 910             SetLastError( ERROR_PATH_NOT_FOUND );
 911             return FALSE;
 912         }
 913
 914         /* Get the long and short name matching the file name */
 915
 916         if ((found = DOSFS_FindUnixName( full->long_name, name, p_l + 1,
 917                          sizeof(full->long_name) - (p_l - full->long_name) - 1,
 918                          p_s + 1, !(flags & DRIVE_CASE_SENSITIVE) )))
 919         {
 920             *p_l++ = '/';
 921             p_l   += strlen(p_l);
 922             *p_s++ = '\\';
 923             p_s   += strlen(p_s);
 924             while (!IS_END_OF_NAME(*name)) name++;
 925         }
 926         else if (!check_last)
 927         {
 928             *p_l++ = '/';
 929             *p_s++ = '\\';
 930             while (!IS_END_OF_NAME(*name) &&
 931                    (p_s < full->short_name + sizeof(full->short_name) - 1) &&
 932                    (p_l < full->long_name + sizeof(full->long_name) - 1))
 933             {
 934                 *p_s++ = FILE_tolower(*name);
 935                 /* If the drive is case-sensitive we want to create new */
 936                 /* files in lower-case otherwise we can't reopen them   */
 937                 /* under the same short name. */
 938                 if (flags & DRIVE_CASE_SENSITIVE) *p_l++ = FILE_tolower(*name);
 939                 else *p_l++ = *name;
 940                 name++;
 941             }
 942             /* Ignore trailing dots and spaces */
 943             while(p_l[-1] == '.' || p_l[-1] == ' ') {
 944                 --p_l;
 945                 --p_s;
 946             }
 947             *p_l = *p_s = '\0';
 948         }
 949         while ((*name == '\\') || (*name == '/')) name++;
 950     }
 951
 952     if (!found)
 953     {
 954         if (check_last)
 955         {
 956             SetLastError( ERROR_FILE_NOT_FOUND );
 957             return FALSE;
 958         }
 959         if (*name)  /* Not last */
 960         {
 961             SetLastError( ERROR_PATH_NOT_FOUND );
 962             return FALSE;
 963         }
 964     }
 965     if (!full->long_name[0]) strcpy( full->long_name, "/" );
 966     if (!full->short_name[2]) strcpy( full->short_name + 2, "\\" );
 967     TRACE("returning %s = %s\n", full->long_name, full->short_name );
 968     return TRUE;
 969 }
 970
 971
 972 /***********************************************************************
 973  *           GetShortPathNameA   (KERNEL32.271)
 974  *
 975  * NOTES
 976  *  observed:
 977  *  longpath=NULL: LastError=ERROR_INVALID_PARAMETER, ret=0
 978  *  *longpath="" or invalid: LastError=ERROR_BAD_PATHNAME, ret=0
 979  *
 980  * more observations ( with NT 3.51 (WinDD) ):
 981  * longpath <= 8.3 -> just copy longpath to shortpath
 982  * longpath > 8.3  ->
 983  *             a) file does not exist -> return 0, LastError = ERROR_FILE_NOT_FOUND
 984  *             b) file does exist     -> set the short filename.
 985  * - trailing slashes are reproduced in the short name, even if the
 986  *   file is not a directory
 987  * - the absolute/relative path of the short name is reproduced like found
 988  *   in the long name
 989  * - longpath and shortpath may have the same adress
 990  * Peter Ganten, 1999
 991  */
 992 DWORD WINAPI GetShortPathNameA( LPCSTR longpath, LPSTR shortpath,
 993                                   DWORD shortlen )
 994 {
 995     DOS_FULL_NAME full_name;
 996     LPSTR tmpshortpath;
 997     DWORD sp = 0, lp = 0;
 998     int tmplen, drive;
 999     UINT flags;
1000
1001     TRACE("%s\n", debugstr_a(longpath));
1002
1003     if (!longpath) {
1004       SetLastError(ERROR_INVALID_PARAMETER);
1005       return 0;
1006     }
1007     if (!longpath[0]) {
1008       SetLastError(ERROR_BAD_PATHNAME);
1009       return 0;
1010     }
1011
1012     if ( ( tmpshortpath = HeapAlloc ( GetProcessHeap(), 0, MAX_PATHNAME_LEN ) ) == NULL ) {
1013       SetLastError ( ERROR_NOT_ENOUGH_MEMORY );
1014       return 0;
1015     }
1016
1017     /* check for drive letter */
1018     if ( longpath[1] == ':' ) {
1019       tmpshortpath[0] = longpath[0];
1020       tmpshortpath[1] = ':';
1021       sp = 2;
1022     }
1023
1024     if ( ( drive = DOSFS_GetPathDrive ( &longpath )) == -1 ) return 0;
1025     flags = DRIVE_GetFlags ( drive );
1026
1027     while ( longpath[lp] ) {
1028
1029       /* check for path delimiters and reproduce them */
1030       if ( longpath[lp] == '\\' || longpath[lp] == '/' ) {
1031         if (!sp || tmpshortpath[sp-1]!= '\\')
1032         {
1033             /* strip double "\\" */
1034             tmpshortpath[sp] = '\\';
1035             sp++;
1036         }
1037         tmpshortpath[sp]=0;/*terminate string*/
1038         lp++;
1039         continue;
1040       }
1041
1042       tmplen = strcspn ( longpath + lp, "\\/" );
1043       lstrcpynA ( tmpshortpath+sp, longpath + lp, tmplen+1 );
1044
1045       /* Check, if the current element is a valid dos name */
1046       if ( DOSFS_ValidDOSName ( longpath + lp, !(flags & DRIVE_CASE_SENSITIVE) ) ) {
1047         sp += tmplen;
1048         lp += tmplen;
1049         continue;
1050       }
1051
1052       /* Check if the file exists and use the existing file name */
1053       if ( DOSFS_GetFullName ( tmpshortpath, TRUE, &full_name ) ) {
1054         strcpy( tmpshortpath+sp, strrchr ( full_name.short_name, '\\' ) + 1 );
1055         sp += strlen ( tmpshortpath+sp );
1056         lp += tmplen;
1057         continue;
1058       }
1059
1060       TRACE("not found!\n" );
1061       SetLastError ( ERROR_FILE_NOT_FOUND );
1062       return 0;
1063     }
1064     tmpshortpath[sp] = 0;
1065
1066     lstrcpynA ( shortpath, tmpshortpath, shortlen );
1067     TRACE("returning %s\n", debugstr_a(shortpath) );
1068     tmplen = strlen ( tmpshortpath );
1069     HeapFree ( GetProcessHeap(), 0, tmpshortpath );
1070
1071     return tmplen;
1072 }
1073
1074
1075 /***********************************************************************
1076  *           GetShortPathNameW   (KERNEL32.272)
1077  */
1078 DWORD WINAPI GetShortPathNameW( LPCWSTR longpath, LPWSTR shortpath,
1079                                   DWORD shortlen )
1080 {
1081     LPSTR longpathA, shortpathA;
1082     DWORD ret = 0;
1083
1084     longpathA = HEAP_strdupWtoA( GetProcessHeap(), 0, longpath );
1085     shortpathA = HeapAlloc ( GetProcessHeap(), 0, shortlen );
1086
1087     ret = GetShortPathNameA ( longpathA, shortpathA, shortlen );
1088     if (shortlen > 0 && !MultiByteToWideChar( CP_ACP, 0, shortpathA, -1, shortpath, shortlen ))
1089         shortpath[shortlen-1] = 0;
1090     HeapFree( GetProcessHeap(), 0, longpathA );
1091     HeapFree( GetProcessHeap(), 0, shortpathA );
1092
1093     return ret;
1094 }
1095
1096
1097 /***********************************************************************
1098  *           GetLongPathNameA   (KERNEL32.xxx)
1099  */
1100 DWORD WINAPI GetLongPathNameA( LPCSTR shortpath, LPSTR longpath,
1101                                   DWORD longlen )
1102 {
1103     DOS_FULL_NAME full_name;
1104     char *p, *r, *ll, *ss;
1105
1106     if (!DOSFS_GetFullName( shortpath, TRUE, &full_name )) return 0;
1107     lstrcpynA( longpath, full_name.short_name, longlen );
1108
1109     /* Do some hackery to get the long filename. */
1110
1111     if (longpath) {
1112      ss=longpath+strlen(longpath);
1113      ll=full_name.long_name+strlen(full_name.long_name);
1114      p=NULL;
1115      while (ss>=longpath)
1116      {
1117        /* FIXME: aren't we more paranoid, than needed? */
1118        while ((ss[0]=='\\') && (ss>=longpath)) ss--;
1119        p=ss;
1120        while ((ss[0]!='\\') && (ss>=longpath)) ss--;
1121        if (ss>=longpath)
1122          {
1123          /* FIXME: aren't we more paranoid, than needed? */
1124          while ((ll[0]=='/') && (ll>=full_name.long_name)) ll--;
1125          while ((ll[0]!='/') && (ll>=full_name.long_name)) ll--;
1126          if (ll<full_name.long_name)
1127               {
1128               ERR("Bad longname! (ss=%s ll=%s)\n This should never happen !\n"
1129                   ,ss ,ll );
1130               return 0;
1131               }
1132          }
1133      }
1134
1135    /* FIXME: fix for names like "C:\\" (ie. with more '\'s) */
1136       if (p && p[2])
1137         {
1138         p+=1;
1139         if ((p-longpath)>0) longlen -= (p-longpath);
1140         lstrcpynA( p, ll , longlen);
1141
1142         /* Now, change all '/' to '\' */
1143         for (r=p; r<(p+longlen); r++ )
1144           if (r[0]=='/') r[0]='\\';
1145         return strlen(longpath) - strlen(p) + longlen;
1146         }
1147     }
1148
1149     return strlen(longpath);
1150 }
1151
1152
1153 /***********************************************************************
1154  *           GetLongPathNameW   (KERNEL32.269)
1155  */
1156 DWORD WINAPI GetLongPathNameW( LPCWSTR shortpath, LPWSTR longpath,
1157                                   DWORD longlen )
1158 {
1159     DOS_FULL_NAME full_name;
1160     DWORD ret = 0;
1161     LPSTR shortpathA = HEAP_strdupWtoA( GetProcessHeap(), 0, shortpath );
1162
1163     /* FIXME: is it correct to always return a fully qualified short path? */
1164     if (DOSFS_GetFullName( shortpathA, TRUE, &full_name ))
1165     {
1166         ret = strlen( full_name.short_name );
1167         if (longlen > 0 && !MultiByteToWideChar( CP_ACP, 0, full_name.long_name, -1,
1168                                                  longpath, longlen ))
1169             longpath[longlen-1] = 0;
1170     }
1171     HeapFree( GetProcessHeap(), 0, shortpathA );
1172     return ret;
1173 }
1174
1175
1176 /***********************************************************************
1177  *           DOSFS_DoGetFullPathName
1178  *
1179  * Implementation of GetFullPathNameA/W.
1180  *
1181  * bon@elektron 000331:
1182  * A test for GetFullPathName with many pathological cases
1183  * now gives identical output for Wine and OSR2
1184  */
1185 static DWORD DOSFS_DoGetFullPathName( LPCSTR name, DWORD len, LPSTR result,
1186                                       BOOL unicode )
1187 {
1188     DWORD ret;
1189     DOS_FULL_NAME full_name;
1190     char *p,*q;
1191     const char * root;
1192     char drivecur[]="c:.";
1193     char driveletter=0;
1194     int namelen,drive=0;
1195
1196     if ((strlen(name) >1)&& (name[1]==':'))
1197       /*drive letter given */
1198       {
1199         driveletter = name[0];
1200       }
1201     if ((strlen(name) >2)&& (name[1]==':') &&
1202              ((name[2]=='\\') || (name[2]=='/')))
1203       /*absolute path given */
1204       {
1205         lstrcpynA(full_name.short_name,name,MAX_PATHNAME_LEN);
1206         drive = (int)FILE_toupper(name[0]) - 'A';
1207       }
1208     else
1209       {
1210         if (driveletter)
1211           drivecur[0]=driveletter;
1212         else
1213           strcpy(drivecur,".");
1214         if (!DOSFS_GetFullName( drivecur, FALSE, &full_name ))
1215           {
1216             FIXME("internal: error getting drive/path\n");
1217             return 0;
1218           }
1219         /* find path that drive letter substitutes*/
1220         drive = (int)FILE_toupper(full_name.short_name[0]) -0x41;
1221         root= DRIVE_GetRoot(drive);
1222         if (!root)
1223           {
1224             FIXME("internal: error getting DOS Drive Root\n");
1225             return 0;
1226           }
1227         if (!strcmp(root,"/"))
1228           {
1229             /* we have just the last / and we need it. */
1230             p= full_name.long_name;
1231           }
1232         else
1233           {
1234             p= full_name.long_name +strlen(root);
1235           }
1236         /* append long name (= unix name) to drive */
1237         lstrcpynA(full_name.short_name+2,p,MAX_PATHNAME_LEN-3);
1238         /* append name to treat */
1239         namelen= strlen(full_name.short_name);
1240         p = (char*)name;
1241         if (driveletter)
1242           p += +2; /* skip drive name when appending */
1243         if (namelen +2  + strlen(p) > MAX_PATHNAME_LEN)
1244           {
1245             FIXME("internal error: buffer too small\n");
1246              return 0;
1247           }
1248         full_name.short_name[namelen++] ='\\';
1249         full_name.short_name[namelen] = 0;
1250         lstrcpynA(full_name.short_name +namelen,p,MAX_PATHNAME_LEN-namelen);
1251       }
1252     /* reverse all slashes */
1253     for (p=full_name.short_name;
1254          p < full_name.short_name+strlen(full_name.short_name);
1255          p++)
1256       {
1257         if ( *p == '/' )
1258           *p = '\\';
1259       }
1260      /* Use memmove, as areas overlap*/
1261      /* Delete .. */
1262     while ((p = strstr(full_name.short_name,"\\..\\")))
1263       {
1264         if (p > full_name.short_name+2)
1265           {
1266             *p = 0;
1267             q = strrchr(full_name.short_name,'\\');
1268             memmove(q+1,p+4,strlen(p+4)+1);
1269           }
1270         else
1271           {
1272             memmove(full_name.short_name+3,p+4,strlen(p+4)+1);
1273           }
1274       }
1275     if ((full_name.short_name[2]=='.')&&(full_name.short_name[3]=='.'))
1276         {
1277           /* This case istn't treated yet : c:..\test */
1278           memmove(full_name.short_name+2,full_name.short_name+4,
1279                   strlen(full_name.short_name+4)+1);
1280         }
1281      /* Delete . */
1282     while ((p = strstr(full_name.short_name,"\\.\\")))
1283       {
1284         *(p+1) = 0;
1285         memmove(p+1,p+3,strlen(p+3)+1);
1286       }
1287     if (!(DRIVE_GetFlags(drive) & DRIVE_CASE_PRESERVING))
1288         for (p = full_name.short_name; *p; p++) *p = FILE_toupper(*p);
1289     namelen=strlen(full_name.short_name);
1290     if (!strcmp(full_name.short_name+namelen-3,"\\.."))
1291         {
1292           /* one more starnge case: "c:\test\test1\.."
1293            return "c:\test"*/
1294           *(full_name.short_name+namelen-3)=0;
1295           q = strrchr(full_name.short_name,'\\');
1296           *q =0;
1297         }
1298     if (full_name.short_name[namelen-1]=='.')
1299         full_name.short_name[(namelen--)-1] =0;
1300     if (!driveletter)
1301       if (full_name.short_name[namelen-1]=='\\')
1302         full_name.short_name[(namelen--)-1] =0;
1303     TRACE("got %s\n",full_name.short_name);
1304
1305     /* If the lpBuffer buffer is too small, the return value is the
1306     size of the buffer, in characters, required to hold the path
1307     plus the terminating \0 (tested against win95osr, bon 001118)
1308     . */
1309     ret = strlen(full_name.short_name);
1310     if (ret >= len )
1311       {
1312         /* don't touch anything when the buffer is not large enough */
1313         SetLastError( ERROR_INSUFFICIENT_BUFFER );
1314         return ret+1;
1315       }
1316     if (result)
1317     {
1318         if (unicode)
1319             MultiByteToWideChar( CP_ACP, 0, full_name.short_name, -1, (LPWSTR)result, len );
1320         else
1321             lstrcpynA( result, full_name.short_name, len );
1322     }
1323
1324     TRACE("returning '%s'\n", full_name.short_name );
1325     return ret;
1326 }
1327
1328
1329 /***********************************************************************
1330  *           GetFullPathNameA   (KERNEL32.272)
1331  * NOTES
1332  *   if the path closed with '\', *lastpart is 0
1333  */
1334 DWORD WINAPI GetFullPathNameA( LPCSTR name, DWORD len, LPSTR buffer,
1335                                  LPSTR *lastpart )
1336 {
1337     DWORD ret = DOSFS_DoGetFullPathName( name, len, buffer, FALSE );
1338     if (ret && (ret<=len) && buffer && lastpart)
1339     {
1340         LPSTR p = buffer + strlen(buffer);
1341
1342         if (*p != '\\')
1343         {
1344           while ((p > buffer + 2) && (*p != '\\')) p--;
1345           *lastpart = p + 1;
1346         }
1347         else *lastpart = NULL;
1348     }
1349     return ret;
1350 }
1351
1352
1353 /***********************************************************************
1354  *           GetFullPathNameW   (KERNEL32.273)
1355  */
1356 DWORD WINAPI GetFullPathNameW( LPCWSTR name, DWORD len, LPWSTR buffer,
1357                                  LPWSTR *lastpart )
1358 {
1359     LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
1360     DWORD ret = DOSFS_DoGetFullPathName( nameA, len, (LPSTR)buffer, TRUE );
1361     HeapFree( GetProcessHeap(), 0, nameA );
1362     if (ret && (ret<=len) && buffer && lastpart)
1363     {
1364         LPWSTR p = buffer + strlenW(buffer);
1365         if (*p != (WCHAR)'\\')
1366         {
1367             while ((p > buffer + 2) && (*p != (WCHAR)'\\')) p--;
1368             *lastpart = p + 1;
1369         }
1370         else *lastpart = NULL;
1371     }
1372     return ret;
1373 }
1374
1375
1376 /***********************************************************************
1377  *           wine_get_unix_file_name   (Not a Windows API, but exported from KERNEL32)
1378  *
1379  * Return the full Unix file name for a given path.
1380  */
1381 BOOL WINAPI wine_get_unix_file_name( LPCSTR dos, LPSTR buffer, DWORD len )
1382 {
1383     BOOL ret;
1384     DOS_FULL_NAME path;
1385     if ((ret = DOSFS_GetFullName( dos, FALSE, &path ))) lstrcpynA( buffer, path.long_name, len );
1386     return ret;
1387 }
1388
1389
1390 /***********************************************************************
1391  *           DOSFS_FindNextEx
1392  */
1393 static int DOSFS_FindNextEx( FIND_FIRST_INFO *info, WIN32_FIND_DATAA *entry )
1394 {
1395     DWORD attr = info->attr | FA_UNUSED | FA_ARCHIVE | FA_RDONLY | FILE_ATTRIBUTE_SYMLINK;
1396     UINT flags = DRIVE_GetFlags( info->drive );
1397     char *p, buffer[MAX_PATHNAME_LEN];
1398     const char *drive_path;
1399     int drive_root;
1400     LPCSTR long_name, short_name;
1401     BY_HANDLE_FILE_INFORMATION fileinfo;
1402     char dos_name[13];
1403
1404     if ((info->attr & ~(FA_UNUSED | FA_ARCHIVE | FA_RDONLY)) == FA_LABEL)
1405     {
1406         if (info->cur_pos) return 0;
1407         entry->dwFileAttributes  = FILE_ATTRIBUTE_LABEL;
1408         RtlSecondsSince1970ToTime( (time_t)0, &entry->ftCreationTime );
1409         RtlSecondsSince1970ToTime( (time_t)0, &entry->ftLastAccessTime );
1410         RtlSecondsSince1970ToTime( (time_t)0, &entry->ftLastWriteTime );
1411         entry->nFileSizeHigh     = 0;
1412         entry->nFileSizeLow      = 0;
1413         entry->dwReserved0       = 0;
1414         entry->dwReserved1       = 0;
1415         DOSFS_ToDosDTAFormat( DRIVE_GetLabel( info->drive ), entry->cFileName );
1416         strcpy( entry->cAlternateFileName, entry->cFileName );
1417         info->cur_pos++;
1418         TRACE("returning %s (%s) as label\n",
1419                entry->cFileName, entry->cAlternateFileName);
1420         return 1;
1421     }
1422
1423     drive_path = info->path + strlen(DRIVE_GetRoot( info->drive ));
1424     while ((*drive_path == '/') || (*drive_path == '\\')) drive_path++;
1425     drive_root = !*drive_path;
1426
1427     lstrcpynA( buffer, info->path, sizeof(buffer) - 1 );
1428     strcat( buffer, "/" );
1429     p = buffer + strlen(buffer);
1430
1431     while (DOSFS_ReadDir( info->dir, &long_name, &short_name ))
1432     {
1433         info->cur_pos++;
1434
1435         /* Don't return '.' and '..' in the root of the drive */
1436         if (drive_root && (long_name[0] == '.') &&
1437             (!long_name[1] || ((long_name[1] == '.') && !long_name[2])))
1438             continue;
1439
1440         /* Check the long mask */
1441
1442         if (info->long_mask)
1443         {
1444             if (!DOSFS_MatchLong( info->long_mask, long_name,
1445                                   flags & DRIVE_CASE_SENSITIVE )) continue;
1446         }
1447
1448         /* Check the short mask */
1449
1450         if (info->short_mask)
1451         {
1452             if (!short_name)
1453             {
1454                 DOSFS_Hash( long_name, dos_name, TRUE,
1455                             !(flags & DRIVE_CASE_SENSITIVE) );
1456                 short_name = dos_name;
1457             }
1458             if (!DOSFS_MatchShort( info->short_mask, short_name )) continue;
1459         }
1460
1461         /* Check the file attributes */
1462
1463         lstrcpynA( p, long_name, sizeof(buffer) - (int)(p - buffer) );
1464         if (!FILE_Stat( buffer, &fileinfo ))
1465         {
1466             WARN("can't stat %s\n", buffer);
1467             continue;
1468         }
1469         if ((fileinfo.dwFileAttributes & FILE_ATTRIBUTE_SYMLINK) &&
1470             (fileinfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
1471         {
1472             static int show_dir_symlinks = -1;
1473             if (show_dir_symlinks == -1)
1474                 show_dir_symlinks = PROFILE_GetWineIniBool("wine", "ShowDirSymlinks", 0);
1475             if (!show_dir_symlinks) continue;
1476         }
1477
1478         if (fileinfo.dwFileAttributes & ~attr) continue;
1479
1480         /* We now have a matching entry; fill the result and return */
1481
1482         entry->dwFileAttributes = fileinfo.dwFileAttributes;
1483         entry->ftCreationTime   = fileinfo.ftCreationTime;
1484         entry->ftLastAccessTime = fileinfo.ftLastAccessTime;
1485         entry->ftLastWriteTime  = fileinfo.ftLastWriteTime;
1486         entry->nFileSizeHigh    = fileinfo.nFileSizeHigh;
1487         entry->nFileSizeLow     = fileinfo.nFileSizeLow;
1488
1489         if (short_name)
1490             DOSFS_ToDosDTAFormat( short_name, entry->cAlternateFileName );
1491         else
1492             DOSFS_Hash( long_name, entry->cAlternateFileName, FALSE,
1493                         !(flags & DRIVE_CASE_SENSITIVE) );
1494
1495         lstrcpynA( entry->cFileName, long_name, sizeof(entry->cFileName) );
1496         if (!(flags & DRIVE_CASE_PRESERVING)) _strlwr( entry->cFileName );
1497         TRACE("returning %s (%s) %02lx %ld\n",
1498               entry->cFileName, entry->cAlternateFileName,
1499               entry->dwFileAttributes, entry->nFileSizeLow );
1500         return 1;
1501     }
1502     return 0;  /* End of directory */
1503 }
1504
1505 /***********************************************************************
1506  *           DOSFS_FindNext
1507  *
1508  * Find the next matching file. Return the number of entries read to find
1509  * the matching one, or 0 if no more entries.
1510  * 'short_mask' is the 8.3 mask (in FCB format), 'long_mask' is the long
1511  * file name mask. Either or both can be NULL.
1512  *
1513  * NOTE: This is supposed to be only called by the int21 emulation
1514  *       routines. Thus, we should own the Win16Mutex anyway.
1515  *       Nevertheless, we explicitly enter it to ensure the static
1516  *       directory cache is protected.
1517  */
1518 int DOSFS_FindNext( const char *path, const char *short_mask,
1519                     const char *long_mask, int drive, BYTE attr,
1520                     int skip, WIN32_FIND_DATAA *entry )
1521 {
1522     static FIND_FIRST_INFO info;
1523     LPCSTR short_name, long_name;
1524     int count;
1525
1526     _EnterWin16Lock();
1527
1528     /* Check the cached directory */
1529     if (!(info.dir && info.path == path && info.short_mask == short_mask
1530                    && info.long_mask == long_mask && info.drive == drive
1531                    && info.attr == attr && info.cur_pos <= skip))
1532     {
1533         /* Not in the cache, open it anew */
1534         if (info.dir) DOSFS_CloseDir( info.dir );
1535
1536         info.path = (LPSTR)path;
1537         info.long_mask = (LPSTR)long_mask;
1538         info.short_mask = (LPSTR)short_mask;
1539         info.attr = attr;
1540         info.drive = drive;
1541         info.cur_pos = 0;
1542         info.dir = DOSFS_OpenDir( info.path );
1543     }
1544
1545     /* Skip to desired position */
1546     while (info.cur_pos < skip)
1547         if (info.dir && DOSFS_ReadDir( info.dir, &long_name, &short_name ))
1548             info.cur_pos++;
1549         else
1550             break;
1551
1552     if (info.dir && info.cur_pos == skip && DOSFS_FindNextEx( &info, entry ))
1553         count = info.cur_pos - skip;
1554     else
1555         count = 0;
1556
1557     if (!count)
1558     {
1559         if (info.dir) DOSFS_CloseDir( info.dir );
1560         memset( &info, '\0', sizeof(info) );
1561     }
1562
1563     _LeaveWin16Lock();
1564
1565     return count;
1566 }
1567
1568 /*************************************************************************
1569  *           FindFirstFileExA  (KERNEL32)
1570  */
1571 HANDLE WINAPI FindFirstFileExA(
1572         LPCSTR lpFileName,
1573         FINDEX_INFO_LEVELS fInfoLevelId,
1574         LPVOID lpFindFileData,
1575         FINDEX_SEARCH_OPS fSearchOp,
1576         LPVOID lpSearchFilter,
1577         DWORD dwAdditionalFlags)
1578 {
1579     DOS_FULL_NAME full_name;
1580     HGLOBAL handle;
1581     FIND_FIRST_INFO *info;
1582
1583     if ((fSearchOp != FindExSearchNameMatch) || (dwAdditionalFlags != 0))
1584     {
1585         FIXME("options not implemented 0x%08x 0x%08lx\n", fSearchOp, dwAdditionalFlags );
1586         return INVALID_HANDLE_VALUE;
1587     }
1588
1589     switch(fInfoLevelId)
1590     {
1591       case FindExInfoStandard:
1592         {
1593           WIN32_FIND_DATAA * data = (WIN32_FIND_DATAA *) lpFindFileData;
1594           data->dwReserved0 = data->dwReserved1 = 0x0;
1595           if (!lpFileName) return 0;
1596           if (!DOSFS_GetFullName( lpFileName, FALSE, &full_name )) break;
1597           if (!(handle = GlobalAlloc(GMEM_MOVEABLE, sizeof(FIND_FIRST_INFO)))) break;
1598           info = (FIND_FIRST_INFO *)GlobalLock( handle );
1599           info->path = HEAP_strdupA( GetProcessHeap(), 0, full_name.long_name );
1600           info->long_mask = strrchr( info->path, '/' );
1601           *(info->long_mask++) = '\0';
1602           info->short_mask = NULL;
1603           info->attr = 0xff;
1604           if (lpFileName[0] && (lpFileName[1] == ':'))
1605               info->drive = FILE_toupper(*lpFileName) - 'A';
1606           else info->drive = DRIVE_GetCurrentDrive();
1607           info->cur_pos = 0;
1608
1609           info->dir = DOSFS_OpenDir( info->path );
1610
1611           GlobalUnlock( handle );
1612           if (!FindNextFileA( handle, data ))
1613           {
1614               FindClose( handle );
1615               SetLastError( ERROR_NO_MORE_FILES );
1616               break;
1617           }
1618           return handle;
1619         }
1620         break;
1621       default:
1622         FIXME("fInfoLevelId 0x%08x not implemented\n", fInfoLevelId );
1623     }
1624     return INVALID_HANDLE_VALUE;
1625 }
1626
1627 /*************************************************************************
1628  *           FindFirstFileA   (KERNEL32.123)
1629  */
1630 HANDLE WINAPI FindFirstFileA(
1631         LPCSTR lpFileName,
1632         WIN32_FIND_DATAA *lpFindData )
1633 {
1634     return FindFirstFileExA(lpFileName, FindExInfoStandard, lpFindData,
1635                             FindExSearchNameMatch, NULL, 0);
1636 }
1637
1638 /*************************************************************************
1639  *           FindFirstFileExW   (KERNEL32)
1640  */
1641 HANDLE WINAPI FindFirstFileExW(
1642         LPCWSTR lpFileName,
1643         FINDEX_INFO_LEVELS fInfoLevelId,
1644         LPVOID lpFindFileData,
1645         FINDEX_SEARCH_OPS fSearchOp,
1646         LPVOID lpSearchFilter,
1647         DWORD dwAdditionalFlags)
1648 {
1649     HANDLE handle;
1650     WIN32_FIND_DATAA dataA;
1651     LPVOID _lpFindFileData;
1652     LPSTR pathA;
1653
1654     switch(fInfoLevelId)
1655     {
1656       case FindExInfoStandard:
1657         {
1658           _lpFindFileData = &dataA;
1659         }
1660         break;
1661       default:
1662         FIXME("fInfoLevelId 0x%08x not implemented\n", fInfoLevelId );
1663         return INVALID_HANDLE_VALUE;
1664     }
1665
1666     pathA = HEAP_strdupWtoA( GetProcessHeap(), 0, lpFileName );
1667     handle = FindFirstFileExA(pathA, fInfoLevelId, _lpFindFileData, fSearchOp, lpSearchFilter, dwAdditionalFlags);
1668     HeapFree( GetProcessHeap(), 0, pathA );
1669     if (handle == INVALID_HANDLE_VALUE) return handle;
1670
1671     switch(fInfoLevelId)
1672     {
1673       case FindExInfoStandard:
1674         {
1675           WIN32_FIND_DATAW *dataW = (WIN32_FIND_DATAW*) lpFindFileData;
1676           dataW->dwFileAttributes = dataA.dwFileAttributes;
1677           dataW->ftCreationTime   = dataA.ftCreationTime;
1678           dataW->ftLastAccessTime = dataA.ftLastAccessTime;
1679           dataW->ftLastWriteTime  = dataA.ftLastWriteTime;
1680           dataW->nFileSizeHigh    = dataA.nFileSizeHigh;
1681           dataW->nFileSizeLow     = dataA.nFileSizeLow;
1682           MultiByteToWideChar( CP_ACP, 0, dataA.cFileName, -1,
1683                                dataW->cFileName, sizeof(dataW->cFileName)/sizeof(WCHAR) );
1684           MultiByteToWideChar( CP_ACP, 0, dataA.cAlternateFileName, -1,
1685                                dataW->cAlternateFileName,
1686                                sizeof(dataW->cAlternateFileName)/sizeof(WCHAR) );
1687         }
1688         break;
1689       default:
1690         FIXME("fInfoLevelId 0x%08x not implemented\n", fInfoLevelId );
1691         return INVALID_HANDLE_VALUE;
1692     }
1693     return handle;
1694 }
1695
1696 /*************************************************************************
1697  *           FindFirstFileW   (KERNEL32.124)
1698  */
1699 HANDLE WINAPI FindFirstFileW( LPCWSTR lpFileName, WIN32_FIND_DATAW *lpFindData )
1700 {
1701     return FindFirstFileExW(lpFileName, FindExInfoStandard, lpFindData,
1702                             FindExSearchNameMatch, NULL, 0);
1703 }
1704
1705 /*************************************************************************
1706  *           FindNextFileA   (KERNEL32.126)
1707  */
1708 BOOL WINAPI FindNextFileA( HANDLE handle, WIN32_FIND_DATAA *data )
1709 {
1710     FIND_FIRST_INFO *info;
1711
1712     if ((handle == INVALID_HANDLE_VALUE) ||
1713        !(info = (FIND_FIRST_INFO *)GlobalLock( handle )))
1714     {
1715         SetLastError( ERROR_INVALID_HANDLE );
1716         return FALSE;
1717     }
1718     GlobalUnlock( handle );
1719     if (!info->path || !info->dir)
1720     {
1721         SetLastError( ERROR_NO_MORE_FILES );
1722         return FALSE;
1723     }
1724     if (!DOSFS_FindNextEx( info, data ))
1725     {
1726         DOSFS_CloseDir( info->dir ); info->dir = NULL;
1727         HeapFree( GetProcessHeap(), 0, info->path );
1728         info->path = info->long_mask = NULL;
1729         SetLastError( ERROR_NO_MORE_FILES );
1730         return FALSE;
1731     }
1732     return TRUE;
1733 }
1734
1735
1736 /*************************************************************************
1737  *           FindNextFileW   (KERNEL32.127)
1738  */
1739 BOOL WINAPI FindNextFileW( HANDLE handle, WIN32_FIND_DATAW *data )
1740 {
1741     WIN32_FIND_DATAA dataA;
1742     if (!FindNextFileA( handle, &dataA )) return FALSE;
1743     data->dwFileAttributes = dataA.dwFileAttributes;
1744     data->ftCreationTime   = dataA.ftCreationTime;
1745     data->ftLastAccessTime = dataA.ftLastAccessTime;
1746     data->ftLastWriteTime  = dataA.ftLastWriteTime;
1747     data->nFileSizeHigh    = dataA.nFileSizeHigh;
1748     data->nFileSizeLow     = dataA.nFileSizeLow;
1749     MultiByteToWideChar( CP_ACP, 0, dataA.cFileName, -1,
1750                          data->cFileName, sizeof(data->cFileName)/sizeof(WCHAR) );
1751     MultiByteToWideChar( CP_ACP, 0, dataA.cAlternateFileName, -1,
1752                          data->cAlternateFileName,
1753                          sizeof(data->cAlternateFileName)/sizeof(WCHAR) );
1754     return TRUE;
1755 }
1756
1757 /*************************************************************************
1758  *           FindClose   (KERNEL32.119)
1759  */
1760 BOOL WINAPI FindClose( HANDLE handle )
1761 {
1762     FIND_FIRST_INFO *info;
1763
1764     if ((handle == INVALID_HANDLE_VALUE) ||
1765         !(info = (FIND_FIRST_INFO *)GlobalLock( handle )))
1766     {
1767         SetLastError( ERROR_INVALID_HANDLE );
1768         return FALSE;
1769     }
1770     if (info->dir) DOSFS_CloseDir( info->dir );
1771     if (info->path) HeapFree( GetProcessHeap(), 0, info->path );
1772     GlobalUnlock( handle );
1773     GlobalFree( handle );
1774     return TRUE;
1775 }
1776
1777 /***********************************************************************
1778  *           DOSFS_UnixTimeToFileTime
1779  *
1780  * Convert a Unix time to FILETIME format.
1781  * The FILETIME structure is a 64-bit value representing the number of
1782  * 100-nanosecond intervals since January 1, 1601, 0:00.
1783  * 'remainder' is the nonnegative number of 100-ns intervals
1784  * corresponding to the time fraction smaller than 1 second that
1785  * couldn't be stored in the time_t value.
1786  */
1787 void DOSFS_UnixTimeToFileTime( time_t unix_time, FILETIME *filetime,
1788                                DWORD remainder )
1789 {
1790     /* NOTES:
1791
1792        CONSTANTS:
1793        The time difference between 1 January 1601, 00:00:00 and
1794        1 January 1970, 00:00:00 is 369 years, plus the leap years
1795        from 1604 to 1968, excluding 1700, 1800, 1900.
1796        This makes (1968 - 1600) / 4 - 3 = 89 leap days, and a total
1797        of 134774 days.
1798
1799        Any day in that period had 24 * 60 * 60 = 86400 seconds.
1800
1801        The time difference is 134774 * 86400 * 10000000, which can be written
1802        116444736000000000
1803        27111902 * 2^32 + 3577643008
1804        413 * 2^48 + 45534 * 2^32 + 54590 * 2^16 + 32768
1805
1806        If you find that these constants are buggy, please change them in all
1807        instances in both conversion functions.
1808
1809        VERSIONS:
1810        There are two versions, one of them uses long long variables and
1811        is presumably faster but not ISO C. The other one uses standard C
1812        data types and operations but relies on the assumption that negative
1813        numbers are stored as 2's complement (-1 is 0xffff....). If this
1814        assumption is violated, dates before 1970 will not convert correctly.
1815        This should however work on any reasonable architecture where WINE
1816        will run.
1817
1818        DETAILS:
1819
1820        Take care not to remove the casts. I have tested these functions
1821        (in both versions) for a lot of numbers. I would be interested in
1822        results on other compilers than GCC.
1823
1824        The operations have been designed to account for the possibility
1825        of 64-bit time_t in future UNICES. Even the versions without
1826        internal long long numbers will work if time_t only is 64 bit.
1827        A 32-bit shift, which was necessary for that operation, turned out
1828        not to work correctly in GCC, besides giving the warning. So I
1829        used a double 16-bit shift instead. Numbers are in the ISO version
1830        represented by three limbs, the most significant with 32 bit, the
1831        other two with 16 bit each.
1832
1833        As the modulo-operator % is not well-defined for negative numbers,
1834        negative divisors have been avoided in DOSFS_FileTimeToUnixTime.
1835
1836        There might be quicker ways to do this in C. Certainly so in
1837        assembler.
1838
1839        Claus Fischer, fischer@iue.tuwien.ac.at
1840        */
1841
1842 #if SIZEOF_LONG_LONG >= 8
1843 #  define USE_LONG_LONG 1
1844 #else
1845 #  define USE_LONG_LONG 0
1846 #endif
1847
1848 #if USE_LONG_LONG               /* gcc supports long long type */
1849
1850     long long int t = unix_time;
1851     t *= 10000000;
1852     t += 116444736000000000LL;
1853     t += remainder;
1854     filetime->dwLowDateTime  = (UINT)t;
1855     filetime->dwHighDateTime = (UINT)(t >> 32);
1856
1857 #else  /* ISO version */
1858
1859     UINT a0;                    /* 16 bit, low    bits */
1860     UINT a1;                    /* 16 bit, medium bits */
1861     UINT a2;                    /* 32 bit, high   bits */
1862
1863     /* Copy the unix time to a2/a1/a0 */
1864     a0 =  unix_time & 0xffff;
1865     a1 = (unix_time >> 16) & 0xffff;
1866     /* This is obsolete if unix_time is only 32 bits, but it does not hurt.
1867        Do not replace this by >> 32, it gives a compiler warning and it does
1868        not work. */
1869     a2 = (unix_time >= 0 ? (unix_time >> 16) >> 16 :
1870           ~((~unix_time >> 16) >> 16));
1871
1872     /* Multiply a by 10000000 (a = a2/a1/a0)
1873        Split the factor into 10000 * 1000 which are both less than 0xffff. */
1874     a0 *= 10000;
1875     a1 = a1 * 10000 + (a0 >> 16);
1876     a2 = a2 * 10000 + (a1 >> 16);
1877     a0 &= 0xffff;
1878     a1 &= 0xffff;
1879
1880     a0 *= 1000;
1881     a1 = a1 * 1000 + (a0 >> 16);
1882     a2 = a2 * 1000 + (a1 >> 16);
1883     a0 &= 0xffff;
1884     a1 &= 0xffff;
1885
1886     /* Add the time difference and the remainder */
1887     a0 += 32768 + (remainder & 0xffff);
1888     a1 += 54590 + (remainder >> 16   ) + (a0 >> 16);
1889     a2 += 27111902                     + (a1 >> 16);
1890     a0 &= 0xffff;
1891     a1 &= 0xffff;
1892
1893     /* Set filetime */
1894     filetime->dwLowDateTime  = (a1 << 16) + a0;
1895     filetime->dwHighDateTime = a2;
1896 #endif
1897 }
1898
1899
1900 /***********************************************************************
1901  *           DOSFS_FileTimeToUnixTime
1902  *
1903  * Convert a FILETIME format to Unix time.
1904  * If not NULL, 'remainder' contains the fractional part of the filetime,
1905  * in the range of [0..9999999] (even if time_t is negative).
1906  */
1907 time_t DOSFS_FileTimeToUnixTime( const FILETIME *filetime, DWORD *remainder )
1908 {
1909     /* Read the comment in the function DOSFS_UnixTimeToFileTime. */
1910 #if USE_LONG_LONG
1911
1912     long long int t = filetime->dwHighDateTime;
1913     t <<= 32;
1914     t += (UINT)filetime->dwLowDateTime;
1915     t -= 116444736000000000LL;
1916     if (t < 0)
1917     {
1918         if (remainder) *remainder = 9999999 - (-t - 1) % 10000000;
1919         return -1 - ((-t - 1) / 10000000);
1920     }
1921     else
1922     {
1923         if (remainder) *remainder = t % 10000000;
1924         return t / 10000000;
1925     }
1926
1927 #else  /* ISO version */
1928
1929     UINT a0;                    /* 16 bit, low    bits */
1930     UINT a1;                    /* 16 bit, medium bits */
1931     UINT a2;                    /* 32 bit, high   bits */
1932     UINT r;                     /* remainder of division */
1933     unsigned int carry;         /* carry bit for subtraction */
1934     int negative;               /* whether a represents a negative value */
1935
1936     /* Copy the time values to a2/a1/a0 */
1937     a2 =  (UINT)filetime->dwHighDateTime;
1938     a1 = ((UINT)filetime->dwLowDateTime ) >> 16;
1939     a0 = ((UINT)filetime->dwLowDateTime ) & 0xffff;
1940
1941     /* Subtract the time difference */
1942     if (a0 >= 32768           ) a0 -=             32768        , carry = 0;
1943     else                        a0 += (1 << 16) - 32768        , carry = 1;
1944
1945     if (a1 >= 54590    + carry) a1 -=             54590 + carry, carry = 0;
1946     else                        a1 += (1 << 16) - 54590 - carry, carry = 1;
1947
1948     a2 -= 27111902 + carry;
1949
1950     /* If a is negative, replace a by (-1-a) */
1951     negative = (a2 >= ((UINT)1) << 31);
1952     if (negative)
1953     {
1954         /* Set a to -a - 1 (a is a2/a1/a0) */
1955         a0 = 0xffff - a0;
1956         a1 = 0xffff - a1;
1957         a2 = ~a2;
1958     }
1959
1960     /* Divide a by 10000000 (a = a2/a1/a0), put the rest into r.
1961        Split the divisor into 10000 * 1000 which are both less than 0xffff. */
1962     a1 += (a2 % 10000) << 16;
1963     a2 /=       10000;
1964     a0 += (a1 % 10000) << 16;
1965     a1 /=       10000;
1966     r   =  a0 % 10000;
1967     a0 /=       10000;
1968
1969     a1 += (a2 % 1000) << 16;
1970     a2 /=       1000;
1971     a0 += (a1 % 1000) << 16;
1972     a1 /=       1000;
1973     r  += (a0 % 1000) * 10000;
1974     a0 /=       1000;
1975
1976     /* If a was negative, replace a by (-1-a) and r by (9999999 - r) */
1977     if (negative)
1978     {
1979         /* Set a to -a - 1 (a is a2/a1/a0) */
1980         a0 = 0xffff - a0;
1981         a1 = 0xffff - a1;
1982         a2 = ~a2;
1983
1984         r  = 9999999 - r;
1985     }
1986
1987     if (remainder) *remainder = r;
1988
1989     /* Do not replace this by << 32, it gives a compiler warning and it does
1990        not work. */
1991     return ((((time_t)a2) << 16) << 16) + (a1 << 16) + a0;
1992 #endif
1993 }
1994
1995
1996 /***********************************************************************
1997  *           MulDiv   (KERNEL32.391)
1998  * RETURNS
1999  *      Result of multiplication and division
2000  *      -1: Overflow occurred or Divisor was 0
2001  */
2002 INT WINAPI MulDiv(
2003              INT nMultiplicand,
2004              INT nMultiplier,
2005              INT nDivisor)
2006 {
2007 #if SIZEOF_LONG_LONG >= 8
2008     long long ret;
2009
2010     if (!nDivisor) return -1;
2011
2012     /* We want to deal with a positive divisor to simplify the logic. */
2013     if (nDivisor < 0)
2014     {
2015       nMultiplicand = - nMultiplicand;
2016       nDivisor = -nDivisor;
2017     }
2018
2019     /* If the result is positive, we "add" to round. else, we subtract to round. */
2020     if ( ( (nMultiplicand <  0) && (nMultiplier <  0) ) ||
2021          ( (nMultiplicand >= 0) && (nMultiplier >= 0) ) )
2022       ret = (((long long)nMultiplicand * nMultiplier) + (nDivisor/2)) / nDivisor;
2023     else
2024       ret = (((long long)nMultiplicand * nMultiplier) - (nDivisor/2)) / nDivisor;
2025
2026     if ((ret > 2147483647) || (ret < -2147483647)) return -1;
2027     return ret;
2028 #else
2029     if (!nDivisor) return -1;
2030
2031     /* We want to deal with a positive divisor to simplify the logic. */
2032     if (nDivisor < 0)
2033     {
2034       nMultiplicand = - nMultiplicand;
2035       nDivisor = -nDivisor;
2036     }
2037
2038     /* If the result is positive, we "add" to round. else, we subtract to round. */
2039     if ( ( (nMultiplicand <  0) && (nMultiplier <  0) ) ||
2040          ( (nMultiplicand >= 0) && (nMultiplier >= 0) ) )
2041       return ((nMultiplicand * nMultiplier) + (nDivisor/2)) / nDivisor;
2042
2043     return ((nMultiplicand * nMultiplier) - (nDivisor/2)) / nDivisor;
2044
2045 #endif
2046 }
2047
2048
2049 /***********************************************************************
2050  *           DosDateTimeToFileTime   (KERNEL32.76)
2051  */
2052 BOOL WINAPI DosDateTimeToFileTime( WORD fatdate, WORD fattime, LPFILETIME ft)
2053 {
2054     struct tm newtm;
2055
2056     newtm.tm_sec  = (fattime & 0x1f) * 2;
2057     newtm.tm_min  = (fattime >> 5) & 0x3f;
2058     newtm.tm_hour = (fattime >> 11);
2059     newtm.tm_mday = (fatdate & 0x1f);
2060     newtm.tm_mon  = ((fatdate >> 5) & 0x0f) - 1;
2061     newtm.tm_year = (fatdate >> 9) + 80;
2062     RtlSecondsSince1970ToTime( mktime( &newtm ), ft );
2063     return TRUE;
2064 }
2065
2066
2067 /***********************************************************************
2068  *           FileTimeToDosDateTime   (KERNEL32.111)
2069  */
2070 BOOL WINAPI FileTimeToDosDateTime( const FILETIME *ft, LPWORD fatdate,
2071                                      LPWORD fattime )
2072 {
2073     time_t unixtime = DOSFS_FileTimeToUnixTime( ft, NULL );
2074     struct tm *tm = localtime( &unixtime );
2075     if (fattime)
2076         *fattime = (tm->tm_hour << 11) + (tm->tm_min << 5) + (tm->tm_sec / 2);
2077     if (fatdate)
2078         *fatdate = ((tm->tm_year - 80) << 9) + ((tm->tm_mon + 1) << 5)
2079                    + tm->tm_mday;
2080     return TRUE;
2081 }
2082
2083
2084 /***********************************************************************
2085  *           LocalFileTimeToFileTime   (KERNEL32.373)
2086  */
2087 BOOL WINAPI LocalFileTimeToFileTime( const FILETIME *localft,
2088                                        LPFILETIME utcft )
2089 {
2090     struct tm *xtm;
2091     DWORD remainder;
2092
2093     /* convert from local to UTC. Perhaps not correct. FIXME */
2094     time_t unixtime = DOSFS_FileTimeToUnixTime( localft, &remainder );
2095     xtm = gmtime( &unixtime );
2096     DOSFS_UnixTimeToFileTime( mktime(xtm), utcft, remainder );
2097     return TRUE;
2098 }
2099
2100
2101 /***********************************************************************
2102  *           FileTimeToLocalFileTime   (KERNEL32.112)
2103  */
2104 BOOL WINAPI FileTimeToLocalFileTime( const FILETIME *utcft,
2105                                        LPFILETIME localft )
2106 {
2107     DWORD remainder;
2108     /* convert from UTC to local. Perhaps not correct. FIXME */
2109     time_t unixtime = DOSFS_FileTimeToUnixTime( utcft, &remainder );
2110 #ifdef HAVE_TIMEGM
2111     struct tm *xtm = localtime( &unixtime );
2112     time_t localtime;
2113
2114     localtime = timegm(xtm);
2115     DOSFS_UnixTimeToFileTime( localtime, localft, remainder );
2116
2117 #else
2118     struct tm *xtm,*gtm;
2119     time_t time1,time2;
2120
2121     xtm = localtime( &unixtime );
2122     gtm = gmtime( &unixtime );
2123     time1 = mktime(xtm);
2124     time2 = mktime(gtm);
2125     DOSFS_UnixTimeToFileTime( 2*time1-time2, localft, remainder );
2126 #endif
2127     return TRUE;
2128 }
2129
2130
2131 /***********************************************************************
2132  *           FileTimeToSystemTime   (KERNEL32.113)
2133  */
2134 BOOL WINAPI FileTimeToSystemTime( const FILETIME *ft, LPSYSTEMTIME syst )
2135 {
2136     struct tm *xtm;
2137     DWORD remainder;
2138     time_t xtime = DOSFS_FileTimeToUnixTime( ft, &remainder );
2139     xtm = gmtime(&xtime);
2140     syst->wYear         = xtm->tm_year+1900;
2141     syst->wMonth        = xtm->tm_mon + 1;
2142     syst->wDayOfWeek    = xtm->tm_wday;
2143     syst->wDay          = xtm->tm_mday;
2144     syst->wHour         = xtm->tm_hour;
2145     syst->wMinute       = xtm->tm_min;
2146     syst->wSecond       = xtm->tm_sec;
2147     syst->wMilliseconds = remainder / 10000;
2148     return TRUE;
2149 }
2150
2151 /***********************************************************************
2152  *           QueryDosDeviceA   (KERNEL32.413)
2153  *
2154  * returns array of strings terminated by \0, terminated by \0
2155  */
2156 DWORD WINAPI QueryDosDeviceA(LPCSTR devname,LPSTR target,DWORD bufsize)
2157 {
2158     LPSTR s;
2159     char  buffer[200];
2160
2161     TRACE("(%s,...)\n", devname ? devname : "<null>");
2162     if (!devname) {
2163         /* return known MSDOS devices */
2164         static const char devices[24] = "CON\0COM1\0COM2\0LPT1\0NUL\0\0";
2165         memcpy( target, devices, min(bufsize,sizeof(devices)) );
2166         return min(bufsize,sizeof(devices));
2167     }
2168     strcpy(buffer,"\\DEV\\");
2169     strcat(buffer,devname);
2170     if ((s=strchr(buffer,':'))) *s='\0';
2171     lstrcpynA(target,buffer,bufsize);
2172     return strlen(buffer)+1;
2173 }
2174
2175
2176 /***********************************************************************
2177  *           QueryDosDeviceW   (KERNEL32.414)
2178  *
2179  * returns array of strings terminated by \0, terminated by \0
2180  */
2181 DWORD WINAPI QueryDosDeviceW(LPCWSTR devname,LPWSTR target,DWORD bufsize)
2182 {
2183     LPSTR devnameA = devname?HEAP_strdupWtoA(GetProcessHeap(),0,devname):NULL;
2184     LPSTR targetA = (LPSTR)HeapAlloc(GetProcessHeap(),0,bufsize);
2185     DWORD ret = QueryDosDeviceA(devnameA,targetA,bufsize);
2186
2187     ret = MultiByteToWideChar( CP_ACP, 0, targetA, ret, target, bufsize );
2188     if (devnameA) HeapFree(GetProcessHeap(),0,devnameA);
2189     if (targetA) HeapFree(GetProcessHeap(),0,targetA);
2190     return ret;
2191 }
2192
2193
2194 /***********************************************************************
2195  *           SystemTimeToFileTime   (KERNEL32.526)
2196  */
2197 BOOL WINAPI SystemTimeToFileTime( const SYSTEMTIME *syst, LPFILETIME ft )
2198 {
2199 #ifdef HAVE_TIMEGM
2200     struct tm xtm;
2201     time_t utctime;
2202 #else
2203     struct tm xtm,*local_tm,*utc_tm;
2204     time_t localtim,utctime;
2205 #endif
2206
2207     xtm.tm_year = syst->wYear-1900;
2208     xtm.tm_mon  = syst->wMonth - 1;
2209     xtm.tm_wday = syst->wDayOfWeek;
2210     xtm.tm_mday = syst->wDay;
2211     xtm.tm_hour = syst->wHour;
2212     xtm.tm_min  = syst->wMinute;
2213     xtm.tm_sec  = syst->wSecond; /* this is UTC */
2214     xtm.tm_isdst = -1;
2215 #ifdef HAVE_TIMEGM
2216     utctime = timegm(&xtm);
2217     DOSFS_UnixTimeToFileTime( utctime, ft,
2218                               syst->wMilliseconds * 10000 );
2219 #else
2220     localtim = mktime(&xtm);    /* now we've got local time */
2221     local_tm = localtime(&localtim);
2222     utc_tm = gmtime(&localtim);
2223     utctime = mktime(utc_tm);
2224     DOSFS_UnixTimeToFileTime( 2*localtim -utctime, ft,
2225                               syst->wMilliseconds * 10000 );
2226 #endif
2227     return TRUE;
2228 }
2229
2230 /***********************************************************************
2231  *           DefineDosDeviceA       (KERNEL32.182)
2232  */
2233 BOOL WINAPI DefineDosDeviceA(DWORD flags,LPCSTR devname,LPCSTR targetpath) {
2234         FIXME("(0x%08lx,%s,%s),stub!\n",flags,devname,targetpath);
2235         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2236         return FALSE;
2237 }
2238
2239 /*
2240    --- 16 bit functions ---
2241 */
2242
2243 /*************************************************************************
2244  *           FindFirstFile16   (KERNEL.413)
2245  */
2246 HANDLE16 WINAPI FindFirstFile16( LPCSTR path, WIN32_FIND_DATAA *data )
2247 {
2248     DOS_FULL_NAME full_name;
2249     HGLOBAL16 handle;
2250     FIND_FIRST_INFO *info;
2251
2252     data->dwReserved0 = data->dwReserved1 = 0x0;
2253     if (!path) return 0;
2254     if (!DOSFS_GetFullName( path, FALSE, &full_name ))
2255         return INVALID_HANDLE_VALUE16;
2256     if (!(handle = GlobalAlloc16( GMEM_MOVEABLE, sizeof(FIND_FIRST_INFO) )))
2257         return INVALID_HANDLE_VALUE16;
2258     info = (FIND_FIRST_INFO *)GlobalLock16( handle );
2259     info->path = HEAP_strdupA( SystemHeap, 0, full_name.long_name );
2260     info->long_mask = strrchr( info->path, '/' );
2261     if (info->long_mask )
2262         *(info->long_mask++) = '\0';
2263     info->short_mask = NULL;
2264     info->attr = 0xff;
2265     if (path[0] && (path[1] == ':')) info->drive = FILE_toupper(*path) - 'A';
2266     else info->drive = DRIVE_GetCurrentDrive();
2267     info->cur_pos = 0;
2268
2269     info->dir = DOSFS_OpenDir( info->path );
2270
2271     GlobalUnlock16( handle );
2272     if (!FindNextFile16( handle, data ))
2273     {
2274         FindClose16( handle );
2275         SetLastError( ERROR_NO_MORE_FILES );
2276         return INVALID_HANDLE_VALUE16;
2277     }
2278     return handle;
2279 }
2280
2281 /*************************************************************************
2282  *           FindNextFile16   (KERNEL.414)
2283  */
2284 BOOL16 WINAPI FindNextFile16( HANDLE16 handle, WIN32_FIND_DATAA *data )
2285 {
2286     FIND_FIRST_INFO *info;
2287
2288     if ((handle == INVALID_HANDLE_VALUE16) ||
2289        !(info = (FIND_FIRST_INFO *)GlobalLock16( handle )))
2290     {
2291         SetLastError( ERROR_INVALID_HANDLE );
2292         return FALSE;
2293     }
2294     GlobalUnlock16( handle );
2295     if (!info->path || !info->dir)
2296     {
2297         SetLastError( ERROR_NO_MORE_FILES );
2298         return FALSE;
2299     }
2300     if (!DOSFS_FindNextEx( info, data ))
2301     {
2302         DOSFS_CloseDir( info->dir ); info->dir = NULL;
2303         HeapFree( SystemHeap, 0, info->path );
2304         info->path = info->long_mask = NULL;
2305         SetLastError( ERROR_NO_MORE_FILES );
2306         return FALSE;
2307     }
2308     return TRUE;
2309 }
2310
2311 /*************************************************************************
2312  *           FindClose16   (KERNEL.415)
2313  */
2314 BOOL16 WINAPI FindClose16( HANDLE16 handle )
2315 {
2316     FIND_FIRST_INFO *info;
2317
2318     if ((handle == INVALID_HANDLE_VALUE16) ||
2319         !(info = (FIND_FIRST_INFO *)GlobalLock16( handle )))
2320     {
2321         SetLastError( ERROR_INVALID_HANDLE );
2322         return FALSE;
2323     }
2324     if (info->dir) DOSFS_CloseDir( info->dir );
2325     if (info->path) HeapFree( SystemHeap, 0, info->path );
2326     GlobalUnlock16( handle );
2327     GlobalFree16( handle );
2328     return TRUE;
2329 }
2330