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