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 (!wine_server_call( req ) && (reply->type == FILE_TYPE_UNKNOWN))
 694         {
 695             if ((reply->attr >= 0) &&
 696                 (reply->attr < sizeof(DOSFS_Devices)/sizeof(DOSFS_Devices[0])))
 697                 ret = &DOSFS_Devices[reply->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, DWORD attributes, LPSECURITY_ATTRIBUTES sa)
 709 {
 710     HANDLE ret;
 711     char devname[40];
 712
 713     TRACE_(file)("%s %lx %lx\n", name, access, attributes);
 714
 715     PROFILE_GetWineIniString("serialports",name,"",devname,sizeof devname);
 716     if(!devname[0])
 717         return 0;
 718
 719     TRACE("opening %s as %s\n", devname, name);
 720
 721     SERVER_START_REQ( create_serial )
 722     {
 723         req->access  = access;
 724         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
 725         req->attributes = attributes;
 726         req->sharing = FILE_SHARE_READ|FILE_SHARE_WRITE;
 727         wine_server_add_data( req, devname, strlen(devname) );
 728         SetLastError(0);
 729         wine_server_call_err( req );
 730         ret = reply->handle;
 731     }
 732     SERVER_END_REQ;
 733
 734     if(!ret)
 735         ERR("Couldn't open device '%s' ! (check permissions)\n",devname);
 736     else
 737         TRACE("return %08X\n", ret );
 738     return ret;
 739 }
 740
 741 /***********************************************************************
 742  *           DOSFS_OpenDevice
 743  *
 744  * Open a DOS device. This might not map 1:1 into the UNIX device concept.
 745  * Returns 0 on failure.
 746  */
 747 HANDLE DOSFS_OpenDevice( const char *name, DWORD access, DWORD attributes, LPSECURITY_ATTRIBUTES sa )
 748 {
 749     int i;
 750     const char *p;
 751     HANDLE handle;
 752
 753     if (name[0] && (name[1] == ':')) name += 2;
 754     if ((p = strrchr( name, '/' ))) name = p + 1;
 755     if ((p = strrchr( name, '\\' ))) name = p + 1;
 756     for (i = 0; i < sizeof(DOSFS_Devices)/sizeof(DOSFS_Devices[0]); i++)
 757     {
 758         const char *dev = DOSFS_Devices[i].name;
 759         if (!FILE_strncasecmp( dev, name, strlen(dev) ))
 760         {
 761             p = name + strlen( dev );
 762             if (!*p || (*p == '.') || (*p == ':')) {
 763                 /* got it */
 764                 if (!strcmp(DOSFS_Devices[i].name,"NUL"))
 765                     return FILE_CreateFile( "/dev/null", access,
 766                                             FILE_SHARE_READ|FILE_SHARE_WRITE, sa,
 767                                             OPEN_EXISTING, 0, 0, TRUE, DRIVE_UNKNOWN );
 768                 if (!strcmp(DOSFS_Devices[i].name,"CON")) {
 769                         HANDLE to_dup;
 770                         switch (access & (GENERIC_READ|GENERIC_WRITE)) {
 771                         case GENERIC_READ:
 772                                 to_dup = GetStdHandle( STD_INPUT_HANDLE );
 773                                 break;
 774                         case GENERIC_WRITE:
 775                                 to_dup = GetStdHandle( STD_OUTPUT_HANDLE );
 776                                 break;
 777                         default:
 778                                 FIXME("can't open CON read/write\n");
 779                                 return 0;
 780                         }
 781                         if (!DuplicateHandle( GetCurrentProcess(), to_dup, GetCurrentProcess(),
 782                                               &handle, 0,
 783                                               sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle,
 784                                               DUPLICATE_SAME_ACCESS ))
 785                             handle = 0;
 786                         return handle;
 787                 }
 788                 if (!strcmp(DOSFS_Devices[i].name,"SCSIMGR$") ||
 789                     !strcmp(DOSFS_Devices[i].name,"HPSCAN"))
 790                 {
 791                     return FILE_CreateDevice( i, access, sa );
 792                 }
 793
 794                 if( (handle=DOSFS_CreateCommPort(DOSFS_Devices[i].name,access,attributes,sa)) )
 795                     return handle;
 796                 FIXME("device open %s not supported (yet)\n",DOSFS_Devices[i].name);
 797                 return 0;
 798             }
 799         }
 800     }
 801     return 0;
 802 }
 803
 804
 805 /***********************************************************************
 806  *           DOSFS_GetPathDrive
 807  *
 808  * Get the drive specified by a given path name (DOS or Unix format).
 809  */
 810 static int DOSFS_GetPathDrive( const char **name )
 811 {
 812     int drive;
 813     const char *p = *name;
 814
 815     if (*p && (p[1] == ':'))
 816     {
 817         drive = FILE_toupper(*p) - 'A';
 818         *name += 2;
 819     }
 820     else if (*p == '/') /* Absolute Unix path? */
 821     {
 822         if ((drive = DRIVE_FindDriveRoot( name )) == -1)
 823         {
 824             MESSAGE("Warning: %s not accessible from a configured DOS drive\n", *name );
 825             /* Assume it really was a DOS name */
 826             drive = DRIVE_GetCurrentDrive();
 827         }
 828     }
 829     else drive = DRIVE_GetCurrentDrive();
 830
 831     if (!DRIVE_IsValid(drive))
 832     {
 833         SetLastError( ERROR_INVALID_DRIVE );
 834         return -1;
 835     }
 836     return drive;
 837 }
 838
 839
 840 /***********************************************************************
 841  *           DOSFS_GetFullName
 842  *
 843  * Convert a file name (DOS or mixed DOS/Unix format) to a valid
 844  * Unix name / short DOS name pair.
 845  * Return FALSE if one of the path components does not exist. The last path
 846  * component is only checked if 'check_last' is non-zero.
 847  * The buffers pointed to by 'long_buf' and 'short_buf' must be
 848  * at least MAX_PATHNAME_LEN long.
 849  */
 850 BOOL DOSFS_GetFullName( LPCSTR name, BOOL check_last, DOS_FULL_NAME *full )
 851 {
 852     BOOL found;
 853     UINT flags;
 854     char *p_l, *p_s, *root;
 855
 856     TRACE("%s (last=%d)\n", name, check_last );
 857
 858     if ((!*name) || (*name=='\n'))
 859     { /* error code for Win98 */
 860         SetLastError(ERROR_BAD_PATHNAME);
 861         return FALSE;
 862     }
 863
 864     if ((full->drive = DOSFS_GetPathDrive( &name )) == -1) return FALSE;
 865     flags = DRIVE_GetFlags( full->drive );
 866
 867     lstrcpynA( full->long_name, DRIVE_GetRoot( full->drive ),
 868                  sizeof(full->long_name) );
 869     if (full->long_name[1]) root = full->long_name + strlen(full->long_name);
 870     else root = full->long_name;  /* root directory */
 871
 872     strcpy( full->short_name, "A:\\" );
 873     full->short_name[0] += full->drive;
 874
 875     if ((*name == '\\') || (*name == '/'))  /* Absolute path */
 876     {
 877         while ((*name == '\\') || (*name == '/')) name++;
 878     }
 879     else  /* Relative path */
 880     {
 881         lstrcpynA( root + 1, DRIVE_GetUnixCwd( full->drive ),
 882                      sizeof(full->long_name) - (root - full->long_name) - 1 );
 883         if (root[1]) *root = '/';
 884         lstrcpynA( full->short_name + 3, DRIVE_GetDosCwd( full->drive ),
 885                      sizeof(full->short_name) - 3 );
 886     }
 887
 888     p_l = full->long_name[1] ? full->long_name + strlen(full->long_name)
 889                              : full->long_name;
 890     p_s = full->short_name[3] ? full->short_name + strlen(full->short_name)
 891                               : full->short_name + 2;
 892     found = TRUE;
 893
 894     while (*name && found)
 895     {
 896         /* Check for '.' and '..' */
 897
 898         if (*name == '.')
 899         {
 900             if (IS_END_OF_NAME(name[1]))
 901             {
 902                 name++;
 903                 while ((*name == '\\') || (*name == '/')) name++;
 904                 continue;
 905             }
 906             else if ((name[1] == '.') && IS_END_OF_NAME(name[2]))
 907             {
 908                 name += 2;
 909                 while ((*name == '\\') || (*name == '/')) name++;
 910                 while ((p_l > root) && (*p_l != '/')) p_l--;
 911                 while ((p_s > full->short_name + 2) && (*p_s != '\\')) p_s--;
 912                 *p_l = *p_s = '\0';  /* Remove trailing separator */
 913                 continue;
 914             }
 915         }
 916
 917         /* Make sure buffers are large enough */
 918
 919         if ((p_s >= full->short_name + sizeof(full->short_name) - 14) ||
 920             (p_l >= full->long_name + sizeof(full->long_name) - 1))
 921         {
 922             SetLastError( ERROR_PATH_NOT_FOUND );
 923             return FALSE;
 924         }
 925
 926         /* Get the long and short name matching the file name */
 927
 928         if ((found = DOSFS_FindUnixName( full->long_name, name, p_l + 1,
 929                          sizeof(full->long_name) - (p_l - full->long_name) - 1,
 930                          p_s + 1, !(flags & DRIVE_CASE_SENSITIVE) )))
 931         {
 932             *p_l++ = '/';
 933             p_l   += strlen(p_l);
 934             *p_s++ = '\\';
 935             p_s   += strlen(p_s);
 936             while (!IS_END_OF_NAME(*name)) name++;
 937         }
 938         else if (!check_last)
 939         {
 940             *p_l++ = '/';
 941             *p_s++ = '\\';
 942             while (!IS_END_OF_NAME(*name) &&
 943                    (p_s < full->short_name + sizeof(full->short_name) - 1) &&
 944                    (p_l < full->long_name + sizeof(full->long_name) - 1))
 945             {
 946                 *p_s++ = FILE_tolower(*name);
 947                 /* If the drive is case-sensitive we want to create new */
 948                 /* files in lower-case otherwise we can't reopen them   */
 949                 /* under the same short name. */
 950                 if (flags & DRIVE_CASE_SENSITIVE) *p_l++ = FILE_tolower(*name);
 951                 else *p_l++ = *name;
 952                 name++;
 953             }
 954             /* Ignore trailing dots and spaces */
 955             while(p_l[-1] == '.' || p_l[-1] == ' ') {
 956                 --p_l;
 957                 --p_s;
 958             }
 959             *p_l = *p_s = '\0';
 960         }
 961         while ((*name == '\\') || (*name == '/')) name++;
 962     }
 963
 964     if (!found)
 965     {
 966         if (check_last)
 967         {
 968             SetLastError( ERROR_FILE_NOT_FOUND );
 969             return FALSE;
 970         }
 971         if (*name)  /* Not last */
 972         {
 973             SetLastError( ERROR_PATH_NOT_FOUND );
 974             return FALSE;
 975         }
 976     }
 977     if (!full->long_name[0]) strcpy( full->long_name, "/" );
 978     if (!full->short_name[2]) strcpy( full->short_name + 2, "\\" );
 979     TRACE("returning %s = %s\n", full->long_name, full->short_name );
 980     return TRUE;
 981 }
 982
 983
 984 /***********************************************************************
 985  *           GetShortPathNameA   (KERNEL32.@)
 986  *
 987  * NOTES
 988  *  observed:
 989  *  longpath=NULL: LastError=ERROR_INVALID_PARAMETER, ret=0
 990  *  longpath="" or invalid: LastError=ERROR_BAD_PATHNAME, ret=0
 991  *
 992  * more observations ( with NT 3.51 (WinDD) ):
 993  * longpath <= 8.3 -> just copy longpath to shortpath
 994  * longpath > 8.3  ->
 995  *             a) file does not exist -> return 0, LastError = ERROR_FILE_NOT_FOUND
 996  *             b) file does exist     -> set the short filename.
 997  * - trailing slashes are reproduced in the short name, even if the
 998  *   file is not a directory
 999  * - the absolute/relative path of the short name is reproduced like found
1000  *   in the long name
1001  * - longpath and shortpath may have the same address
1002  * Peter Ganten, 1999
1003  */
1004 DWORD WINAPI GetShortPathNameA( LPCSTR longpath, LPSTR shortpath,
1005                                   DWORD shortlen )
1006 {
1007     DOS_FULL_NAME full_name;
1008     LPSTR tmpshortpath;
1009     DWORD sp = 0, lp = 0;
1010     int tmplen, drive;
1011     UINT flags;
1012
1013     TRACE("%s\n", debugstr_a(longpath));
1014
1015     if (!longpath) {
1016       SetLastError(ERROR_INVALID_PARAMETER);
1017       return 0;
1018     }
1019     if (!longpath[0]) {
1020       SetLastError(ERROR_BAD_PATHNAME);
1021       return 0;
1022     }
1023
1024     if ( ( tmpshortpath = HeapAlloc ( GetProcessHeap(), 0, MAX_PATHNAME_LEN ) ) == NULL ) {
1025       SetLastError ( ERROR_NOT_ENOUGH_MEMORY );
1026       return 0;
1027     }
1028
1029     /* check for drive letter */
1030     if ( longpath[1] == ':' ) {
1031       tmpshortpath[0] = longpath[0];
1032       tmpshortpath[1] = ':';
1033       sp = 2;
1034     }
1035
1036     if ( ( drive = DOSFS_GetPathDrive ( &longpath )) == -1 ) return 0;
1037     flags = DRIVE_GetFlags ( drive );
1038
1039     while ( longpath[lp] ) {
1040
1041       /* check for path delimiters and reproduce them */
1042       if ( longpath[lp] == '\\' || longpath[lp] == '/' ) {
1043         if (!sp || tmpshortpath[sp-1]!= '\\')
1044         {
1045             /* strip double "\\" */
1046             tmpshortpath[sp] = '\\';
1047             sp++;
1048         }
1049         tmpshortpath[sp]=0;/*terminate string*/
1050         lp++;
1051         continue;
1052       }
1053
1054       tmplen = strcspn ( longpath + lp, "\\/" );
1055       lstrcpynA ( tmpshortpath+sp, longpath + lp, tmplen+1 );
1056
1057       /* Check, if the current element is a valid dos name */
1058       if ( DOSFS_ValidDOSName ( longpath + lp, !(flags & DRIVE_CASE_SENSITIVE) ) ) {
1059         sp += tmplen;
1060         lp += tmplen;
1061         continue;
1062       }
1063
1064       /* Check if the file exists and use the existing file name */
1065       if ( DOSFS_GetFullName ( tmpshortpath, TRUE, &full_name ) ) {
1066         strcpy( tmpshortpath+sp, strrchr ( full_name.short_name, '\\' ) + 1 );
1067         sp += strlen ( tmpshortpath+sp );
1068         lp += tmplen;
1069         continue;
1070       }
1071
1072       TRACE("not found!\n" );
1073       SetLastError ( ERROR_FILE_NOT_FOUND );
1074       return 0;
1075     }
1076     tmpshortpath[sp] = 0;
1077
1078     lstrcpynA ( shortpath, tmpshortpath, shortlen );
1079     TRACE("returning %s\n", debugstr_a(shortpath) );
1080     tmplen = strlen ( tmpshortpath );
1081     HeapFree ( GetProcessHeap(), 0, tmpshortpath );
1082
1083     return tmplen;
1084 }
1085
1086
1087 /***********************************************************************
1088  *           GetShortPathNameW   (KERNEL32.@)
1089  */
1090 DWORD WINAPI GetShortPathNameW( LPCWSTR longpath, LPWSTR shortpath,
1091                                   DWORD shortlen )
1092 {
1093     LPSTR longpathA, shortpathA;
1094     DWORD ret = 0;
1095
1096     longpathA = HEAP_strdupWtoA( GetProcessHeap(), 0, longpath );
1097     shortpathA = HeapAlloc ( GetProcessHeap(), 0, shortlen );
1098
1099     ret = GetShortPathNameA ( longpathA, shortpathA, shortlen );
1100     if (shortlen > 0 && !MultiByteToWideChar( CP_ACP, 0, shortpathA, -1, shortpath, shortlen ))
1101         shortpath[shortlen-1] = 0;
1102     HeapFree( GetProcessHeap(), 0, longpathA );
1103     HeapFree( GetProcessHeap(), 0, shortpathA );
1104
1105     return ret;
1106 }
1107
1108
1109 /***********************************************************************
1110  *           GetLongPathNameA   (KERNEL32.@)
1111  *
1112  * NOTES
1113  *  observed (Win2000):
1114  *  shortpath=NULL: LastError=ERROR_INVALID_PARAMETER, ret=0
1115  *  shortpath="":   LastError=ERROR_PATH_NOT_FOUND, ret=0
1116  */
1117 DWORD WINAPI GetLongPathNameA( LPCSTR shortpath, LPSTR longpath,
1118                                   DWORD longlen )
1119 {
1120     DOS_FULL_NAME full_name;
1121     char *p, *r, *ll, *ss;
1122
1123     if (!shortpath) {
1124       SetLastError(ERROR_INVALID_PARAMETER);
1125       return 0;
1126     }
1127     if (!shortpath[0]) {
1128       SetLastError(ERROR_PATH_NOT_FOUND);
1129       return 0;
1130     }
1131
1132     if (!DOSFS_GetFullName( shortpath, TRUE, &full_name )) return 0;
1133     lstrcpynA( longpath, full_name.short_name, longlen );
1134
1135     /* Do some hackery to get the long filename. */
1136
1137     if (longpath) {
1138      ss=longpath+strlen(longpath);
1139      ll=full_name.long_name+strlen(full_name.long_name);
1140      p=NULL;
1141      while (ss>=longpath)
1142      {
1143        /* FIXME: aren't we more paranoid, than needed? */
1144        while ((ss[0]=='\\') && (ss>=longpath)) ss--;
1145        p=ss;
1146        while ((ss[0]!='\\') && (ss>=longpath)) ss--;
1147        if (ss>=longpath)
1148          {
1149          /* FIXME: aren't we more paranoid, than needed? */
1150          while ((ll[0]=='/') && (ll>=full_name.long_name)) ll--;
1151          while ((ll[0]!='/') && (ll>=full_name.long_name)) ll--;
1152          if (ll<full_name.long_name)
1153               {
1154               ERR("Bad longname! (ss=%s ll=%s)\n This should never happen !\n"
1155                   ,ss ,ll );
1156               return 0;
1157               }
1158          }
1159      }
1160
1161    /* FIXME: fix for names like "C:\\" (ie. with more '\'s) */
1162       if (p && p[2])
1163         {
1164         p+=1;
1165         if ((p-longpath)>0) longlen -= (p-longpath);
1166         lstrcpynA( p, ll , longlen);
1167
1168         /* Now, change all '/' to '\' */
1169         for (r=p; r<(p+longlen); r++ )
1170           if (r[0]=='/') r[0]='\\';
1171         return strlen(longpath) - strlen(p) + longlen;
1172         }
1173     }
1174
1175     return strlen(longpath);
1176 }
1177
1178
1179 /***********************************************************************
1180  *           GetLongPathNameW   (KERNEL32.@)
1181  */
1182 DWORD WINAPI GetLongPathNameW( LPCWSTR shortpath, LPWSTR longpath,
1183                                   DWORD longlen )
1184 {
1185     DOS_FULL_NAME full_name;
1186     DWORD ret = 0;
1187     LPSTR shortpathA = HEAP_strdupWtoA( GetProcessHeap(), 0, shortpath );
1188
1189     /* FIXME: is it correct to always return a fully qualified short path? */
1190     if (DOSFS_GetFullName( shortpathA, TRUE, &full_name ))
1191     {
1192         ret = strlen( full_name.short_name );
1193         if (longlen > 0 && !MultiByteToWideChar( CP_ACP, 0, full_name.long_name, -1,
1194                                                  longpath, longlen ))
1195             longpath[longlen-1] = 0;
1196     }
1197     HeapFree( GetProcessHeap(), 0, shortpathA );
1198     return ret;
1199 }
1200
1201
1202 /***********************************************************************
1203  *           DOSFS_DoGetFullPathName
1204  *
1205  * Implementation of GetFullPathNameA/W.
1206  *
1207  * bon@elektron 000331:
1208  * A test for GetFullPathName with many pathological cases
1209  * now gives identical output for Wine and OSR2
1210  */
1211 static DWORD DOSFS_DoGetFullPathName( LPCSTR name, DWORD len, LPSTR result,
1212                                       BOOL unicode )
1213 {
1214     DWORD ret;
1215     DOS_FULL_NAME full_name;
1216     char *p,*q;
1217     const char * root;
1218     char drivecur[]="c:.";
1219     char driveletter=0;
1220     int namelen,drive=0;
1221
1222     if ((strlen(name) >1)&& (name[1]==':'))
1223       /* drive letter given */
1224       {
1225         driveletter = name[0];
1226       }
1227     if ((strlen(name) >2)&& (name[1]==':') &&
1228              ((name[2]=='\\') || (name[2]=='/')))
1229       /* absolute path given */
1230       {
1231         lstrcpynA(full_name.short_name,name,MAX_PATHNAME_LEN);
1232         drive = (int)FILE_toupper(name[0]) - 'A';
1233       }
1234     else
1235       {
1236         if (driveletter)
1237           drivecur[0]=driveletter;
1238         else
1239           strcpy(drivecur,".");
1240         if (!DOSFS_GetFullName( drivecur, FALSE, &full_name ))
1241           {
1242             FIXME("internal: error getting drive/path\n");
1243             return 0;
1244           }
1245         /* find path that drive letter substitutes*/
1246         drive = (int)FILE_toupper(full_name.short_name[0]) -0x41;
1247         root= DRIVE_GetRoot(drive);
1248         if (!root)
1249           {
1250             FIXME("internal: error getting DOS Drive Root\n");
1251             return 0;
1252           }
1253         if (!strcmp(root,"/"))
1254           {
1255             /* we have just the last / and we need it. */
1256             p= full_name.long_name;
1257           }
1258         else
1259           {
1260             p= full_name.long_name +strlen(root);
1261           }
1262         /* append long name (= unix name) to drive */
1263         lstrcpynA(full_name.short_name+2,p,MAX_PATHNAME_LEN-3);
1264         /* append name to treat */
1265         namelen= strlen(full_name.short_name);
1266         p = (char*)name;
1267         if (driveletter)
1268           p += +2; /* skip drive name when appending */
1269         if (namelen +2  + strlen(p) > MAX_PATHNAME_LEN)
1270           {
1271             FIXME("internal error: buffer too small\n");
1272              return 0;
1273           }
1274         full_name.short_name[namelen++] ='\\';
1275         full_name.short_name[namelen] = 0;
1276         lstrcpynA(full_name.short_name +namelen,p,MAX_PATHNAME_LEN-namelen);
1277       }
1278     /* reverse all slashes */
1279     for (p=full_name.short_name;
1280          p < full_name.short_name+strlen(full_name.short_name);
1281          p++)
1282       {
1283         if ( *p == '/' )
1284           *p = '\\';
1285       }
1286      /* Use memmove, as areas overlap */
1287      /* Delete .. */
1288     while ((p = strstr(full_name.short_name,"\\..\\")))
1289       {
1290         if (p > full_name.short_name+2)
1291           {
1292             *p = 0;
1293             q = strrchr(full_name.short_name,'\\');
1294             memmove(q+1,p+4,strlen(p+4)+1);
1295           }
1296         else
1297           {
1298             memmove(full_name.short_name+3,p+4,strlen(p+4)+1);
1299           }
1300       }
1301     if ((full_name.short_name[2]=='.')&&(full_name.short_name[3]=='.'))
1302         {
1303           /* This case istn't treated yet : c:..\test */
1304           memmove(full_name.short_name+2,full_name.short_name+4,
1305                   strlen(full_name.short_name+4)+1);
1306         }
1307      /* Delete . */
1308     while ((p = strstr(full_name.short_name,"\\.\\")))
1309       {
1310         *(p+1) = 0;
1311         memmove(p+1,p+3,strlen(p+3)+1);
1312       }
1313     if (!(DRIVE_GetFlags(drive) & DRIVE_CASE_PRESERVING))
1314         for (p = full_name.short_name; *p; p++) *p = FILE_toupper(*p);
1315     namelen=strlen(full_name.short_name);
1316     if (!strcmp(full_name.short_name+namelen-3,"\\.."))
1317         {
1318           /* one more strange case: "c:\test\test1\.."
1319            return "c:\test" */
1320           *(full_name.short_name+namelen-3)=0;
1321           q = strrchr(full_name.short_name,'\\');
1322           *q =0;
1323         }
1324     if (full_name.short_name[namelen-1]=='.')
1325         full_name.short_name[(namelen--)-1] =0;
1326     if (!driveletter)
1327       if (full_name.short_name[namelen-1]=='\\')
1328         full_name.short_name[(namelen--)-1] =0;
1329     TRACE("got %s\n",full_name.short_name);
1330
1331     /* If the lpBuffer buffer is too small, the return value is the
1332     size of the buffer, in characters, required to hold the path
1333     plus the terminating \0 (tested against win95osr2, bon 001118)
1334     . */
1335     ret = strlen(full_name.short_name);
1336     if (ret >= len )
1337       {
1338         /* don't touch anything when the buffer is not large enough */
1339         SetLastError( ERROR_INSUFFICIENT_BUFFER );
1340         return ret+1;
1341       }
1342     if (result)
1343     {
1344         if (unicode)
1345             MultiByteToWideChar( CP_ACP, 0, full_name.short_name, -1, (LPWSTR)result, len );
1346         else
1347             lstrcpynA( result, full_name.short_name, len );
1348     }
1349
1350     TRACE("returning '%s'\n", full_name.short_name );
1351     return ret;
1352 }
1353
1354
1355 /***********************************************************************
1356  *           GetFullPathNameA   (KERNEL32.@)
1357  * NOTES
1358  *   if the path closed with '\', *lastpart is 0
1359  */
1360 DWORD WINAPI GetFullPathNameA( LPCSTR name, DWORD len, LPSTR buffer,
1361                                  LPSTR *lastpart )
1362 {
1363     DWORD ret = DOSFS_DoGetFullPathName( name, len, buffer, FALSE );
1364     if (ret && (ret<=len) && buffer && lastpart)
1365     {
1366         LPSTR p = buffer + strlen(buffer);
1367
1368         if (*p != '\\')
1369         {
1370           while ((p > buffer + 2) && (*p != '\\')) p--;
1371           *lastpart = p + 1;
1372         }
1373         else *lastpart = NULL;
1374     }
1375     return ret;
1376 }
1377
1378
1379 /***********************************************************************
1380  *           GetFullPathNameW   (KERNEL32.@)
1381  */
1382 DWORD WINAPI GetFullPathNameW( LPCWSTR name, DWORD len, LPWSTR buffer,
1383                                  LPWSTR *lastpart )
1384 {
1385     LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
1386     DWORD ret = DOSFS_DoGetFullPathName( nameA, len, (LPSTR)buffer, TRUE );
1387     HeapFree( GetProcessHeap(), 0, nameA );
1388     if (ret && (ret<=len) && buffer && lastpart)
1389     {
1390         LPWSTR p = buffer + strlenW(buffer);
1391         if (*p != (WCHAR)'\\')
1392         {
1393             while ((p > buffer + 2) && (*p != (WCHAR)'\\')) p--;
1394             *lastpart = p + 1;
1395         }
1396         else *lastpart = NULL;
1397     }
1398     return ret;
1399 }
1400
1401
1402 /***********************************************************************
1403  *           wine_get_unix_file_name (KERNEL32.@) Not a Windows API
1404  *
1405  * Return the full Unix file name for a given path.
1406  */
1407 BOOL WINAPI wine_get_unix_file_name( LPCSTR dos, LPSTR buffer, DWORD len )
1408 {
1409     BOOL ret;
1410     DOS_FULL_NAME path;
1411     if ((ret = DOSFS_GetFullName( dos, FALSE, &path ))) lstrcpynA( buffer, path.long_name, len );
1412     return ret;
1413 }
1414
1415
1416 /***********************************************************************
1417  *           DOSFS_FindNextEx
1418  */
1419 static int DOSFS_FindNextEx( FIND_FIRST_INFO *info, WIN32_FIND_DATAA *entry )
1420 {
1421     DWORD attr = info->attr | FA_UNUSED | FA_ARCHIVE | FA_RDONLY | FILE_ATTRIBUTE_SYMLINK;
1422     UINT flags = DRIVE_GetFlags( info->drive );
1423     char *p, buffer[MAX_PATHNAME_LEN];
1424     const char *drive_path;
1425     int drive_root;
1426     LPCSTR long_name, short_name;
1427     BY_HANDLE_FILE_INFORMATION fileinfo;
1428     char dos_name[13];
1429
1430     if ((info->attr & ~(FA_UNUSED | FA_ARCHIVE | FA_RDONLY)) == FA_LABEL)
1431     {
1432         if (info->cur_pos) return 0;
1433         entry->dwFileAttributes  = FILE_ATTRIBUTE_LABEL;
1434         RtlSecondsSince1970ToTime( (time_t)0, &entry->ftCreationTime );
1435         RtlSecondsSince1970ToTime( (time_t)0, &entry->ftLastAccessTime );
1436         RtlSecondsSince1970ToTime( (time_t)0, &entry->ftLastWriteTime );
1437         entry->nFileSizeHigh     = 0;
1438         entry->nFileSizeLow      = 0;
1439         entry->dwReserved0       = 0;
1440         entry->dwReserved1       = 0;
1441         DOSFS_ToDosDTAFormat( DRIVE_GetLabel( info->drive ), entry->cFileName );
1442         strcpy( entry->cAlternateFileName, entry->cFileName );
1443         info->cur_pos++;
1444         TRACE("returning %s (%s) as label\n",
1445                entry->cFileName, entry->cAlternateFileName);
1446         return 1;
1447     }
1448
1449     drive_path = info->path + strlen(DRIVE_GetRoot( info->drive ));
1450     while ((*drive_path == '/') || (*drive_path == '\\')) drive_path++;
1451     drive_root = !*drive_path;
1452
1453     lstrcpynA( buffer, info->path, sizeof(buffer) - 1 );
1454     strcat( buffer, "/" );
1455     p = buffer + strlen(buffer);
1456
1457     while (DOSFS_ReadDir( info->dir, &long_name, &short_name ))
1458     {
1459         info->cur_pos++;
1460
1461         /* Don't return '.' and '..' in the root of the drive */
1462         if (drive_root && (long_name[0] == '.') &&
1463             (!long_name[1] || ((long_name[1] == '.') && !long_name[2])))
1464             continue;
1465
1466         /* Check the long mask */
1467
1468         if (info->long_mask)
1469         {
1470             if (!DOSFS_MatchLong( info->long_mask, long_name,
1471                                   flags & DRIVE_CASE_SENSITIVE )) continue;
1472         }
1473
1474         /* Check the short mask */
1475
1476         if (info->short_mask)
1477         {
1478             if (!short_name)
1479             {
1480                 DOSFS_Hash( long_name, dos_name, TRUE,
1481                             !(flags & DRIVE_CASE_SENSITIVE) );
1482                 short_name = dos_name;
1483             }
1484             if (!DOSFS_MatchShort( info->short_mask, short_name )) continue;
1485         }
1486
1487         /* Check the file attributes */
1488
1489         lstrcpynA( p, long_name, sizeof(buffer) - (int)(p - buffer) );
1490         if (!FILE_Stat( buffer, &fileinfo ))
1491         {
1492             WARN("can't stat %s\n", buffer);
1493             continue;
1494         }
1495         if ((fileinfo.dwFileAttributes & FILE_ATTRIBUTE_SYMLINK) &&
1496             (fileinfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
1497         {
1498             static int show_dir_symlinks = -1;
1499             if (show_dir_symlinks == -1)
1500                 show_dir_symlinks = PROFILE_GetWineIniBool("wine", "ShowDirSymlinks", 0);
1501             if (!show_dir_symlinks) continue;
1502         }
1503
1504         if (fileinfo.dwFileAttributes & ~attr) continue;
1505
1506         /* We now have a matching entry; fill the result and return */
1507
1508         entry->dwFileAttributes = fileinfo.dwFileAttributes;
1509         entry->ftCreationTime   = fileinfo.ftCreationTime;
1510         entry->ftLastAccessTime = fileinfo.ftLastAccessTime;
1511         entry->ftLastWriteTime  = fileinfo.ftLastWriteTime;
1512         entry->nFileSizeHigh    = fileinfo.nFileSizeHigh;
1513         entry->nFileSizeLow     = fileinfo.nFileSizeLow;
1514
1515         if (short_name)
1516             DOSFS_ToDosDTAFormat( short_name, entry->cAlternateFileName );
1517         else
1518             DOSFS_Hash( long_name, entry->cAlternateFileName, FALSE,
1519                         !(flags & DRIVE_CASE_SENSITIVE) );
1520
1521         lstrcpynA( entry->cFileName, long_name, sizeof(entry->cFileName) );
1522         if (!(flags & DRIVE_CASE_PRESERVING)) _strlwr( entry->cFileName );
1523         TRACE("returning %s (%s) %02lx %ld\n",
1524               entry->cFileName, entry->cAlternateFileName,
1525               entry->dwFileAttributes, entry->nFileSizeLow );
1526         return 1;
1527     }
1528     return 0;  /* End of directory */
1529 }
1530
1531 /***********************************************************************
1532  *           DOSFS_FindNext
1533  *
1534  * Find the next matching file. Return the number of entries read to find
1535  * the matching one, or 0 if no more entries.
1536  * 'short_mask' is the 8.3 mask (in FCB format), 'long_mask' is the long
1537  * file name mask. Either or both can be NULL.
1538  *
1539  * NOTE: This is supposed to be only called by the int21 emulation
1540  *       routines. Thus, we should own the Win16Mutex anyway.
1541  *       Nevertheless, we explicitly enter it to ensure the static
1542  *       directory cache is protected.
1543  */
1544 int DOSFS_FindNext( const char *path, const char *short_mask,
1545                     const char *long_mask, int drive, BYTE attr,
1546                     int skip, WIN32_FIND_DATAA *entry )
1547 {
1548     static FIND_FIRST_INFO info;
1549     LPCSTR short_name, long_name;
1550     int count;
1551
1552     _EnterWin16Lock();
1553
1554     /* Check the cached directory */
1555     if (!(info.dir && info.path == path && info.short_mask == short_mask
1556                    && info.long_mask == long_mask && info.drive == drive
1557                    && info.attr == attr && info.cur_pos <= skip))
1558     {
1559         /* Not in the cache, open it anew */
1560         if (info.dir) DOSFS_CloseDir( info.dir );
1561
1562         info.path = (LPSTR)path;
1563         info.long_mask = (LPSTR)long_mask;
1564         info.short_mask = (LPSTR)short_mask;
1565         info.attr = attr;
1566         info.drive = drive;
1567         info.cur_pos = 0;
1568         info.dir = DOSFS_OpenDir( info.path );
1569     }
1570
1571     /* Skip to desired position */
1572     while (info.cur_pos < skip)
1573         if (info.dir && DOSFS_ReadDir( info.dir, &long_name, &short_name ))
1574             info.cur_pos++;
1575         else
1576             break;
1577
1578     if (info.dir && info.cur_pos == skip && DOSFS_FindNextEx( &info, entry ))
1579         count = info.cur_pos - skip;
1580     else
1581         count = 0;
1582
1583     if (!count)
1584     {
1585         if (info.dir) DOSFS_CloseDir( info.dir );
1586         memset( &info, '\0', sizeof(info) );
1587     }
1588
1589     _LeaveWin16Lock();
1590
1591     return count;
1592 }
1593
1594 /*************************************************************************
1595  *           FindFirstFileExA  (KERNEL32.@)
1596  */
1597 HANDLE WINAPI FindFirstFileExA(
1598         LPCSTR lpFileName,
1599         FINDEX_INFO_LEVELS fInfoLevelId,
1600         LPVOID lpFindFileData,
1601         FINDEX_SEARCH_OPS fSearchOp,
1602         LPVOID lpSearchFilter,
1603         DWORD dwAdditionalFlags)
1604 {
1605     DOS_FULL_NAME full_name;
1606     HGLOBAL handle;
1607     FIND_FIRST_INFO *info;
1608
1609     if ((fSearchOp != FindExSearchNameMatch) || (dwAdditionalFlags != 0))
1610     {
1611         FIXME("options not implemented 0x%08x 0x%08lx\n", fSearchOp, dwAdditionalFlags );
1612         return INVALID_HANDLE_VALUE;
1613     }
1614
1615     switch(fInfoLevelId)
1616     {
1617       case FindExInfoStandard:
1618         {
1619           WIN32_FIND_DATAA * data = (WIN32_FIND_DATAA *) lpFindFileData;
1620           data->dwReserved0 = data->dwReserved1 = 0x0;
1621           if (!lpFileName) return 0;
1622           if (!DOSFS_GetFullName( lpFileName, FALSE, &full_name )) break;
1623           if (!(handle = GlobalAlloc(GMEM_MOVEABLE, sizeof(FIND_FIRST_INFO)))) break;
1624           info = (FIND_FIRST_INFO *)GlobalLock( handle );
1625           info->path = HeapAlloc( GetProcessHeap(), 0, strlen(full_name.long_name)+1 );
1626           strcpy( info->path, full_name.long_name );
1627           info->long_mask = strrchr( info->path, '/' );
1628           *(info->long_mask++) = '\0';
1629           info->short_mask = NULL;
1630           info->attr = 0xff;
1631           if (lpFileName[0] && (lpFileName[1] == ':'))
1632               info->drive = FILE_toupper(*lpFileName) - 'A';
1633           else info->drive = DRIVE_GetCurrentDrive();
1634           info->cur_pos = 0;
1635
1636           info->dir = DOSFS_OpenDir( info->path );
1637
1638           GlobalUnlock( handle );
1639           if (!FindNextFileA( handle, data ))
1640           {
1641               FindClose( handle );
1642               SetLastError( ERROR_NO_MORE_FILES );
1643               break;
1644           }
1645           return handle;
1646         }
1647         break;
1648       default:
1649         FIXME("fInfoLevelId 0x%08x not implemented\n", fInfoLevelId );
1650     }
1651     return INVALID_HANDLE_VALUE;
1652 }
1653
1654 /*************************************************************************
1655  *           FindFirstFileA   (KERNEL32.@)
1656  */
1657 HANDLE WINAPI FindFirstFileA(
1658         LPCSTR lpFileName,
1659         WIN32_FIND_DATAA *lpFindData )
1660 {
1661     return FindFirstFileExA(lpFileName, FindExInfoStandard, lpFindData,
1662                             FindExSearchNameMatch, NULL, 0);
1663 }
1664
1665 /*************************************************************************
1666  *           FindFirstFileExW   (KERNEL32.@)
1667  */
1668 HANDLE WINAPI FindFirstFileExW(
1669         LPCWSTR lpFileName,
1670         FINDEX_INFO_LEVELS fInfoLevelId,
1671         LPVOID lpFindFileData,
1672         FINDEX_SEARCH_OPS fSearchOp,
1673         LPVOID lpSearchFilter,
1674         DWORD dwAdditionalFlags)
1675 {
1676     HANDLE handle;
1677     WIN32_FIND_DATAA dataA;
1678     LPVOID _lpFindFileData;
1679     LPSTR pathA;
1680
1681     switch(fInfoLevelId)
1682     {
1683       case FindExInfoStandard:
1684         {
1685           _lpFindFileData = &dataA;
1686         }
1687         break;
1688       default:
1689         FIXME("fInfoLevelId 0x%08x not implemented\n", fInfoLevelId );
1690         return INVALID_HANDLE_VALUE;
1691     }
1692
1693     pathA = HEAP_strdupWtoA( GetProcessHeap(), 0, lpFileName );
1694     handle = FindFirstFileExA(pathA, fInfoLevelId, _lpFindFileData, fSearchOp, lpSearchFilter, dwAdditionalFlags);
1695     HeapFree( GetProcessHeap(), 0, pathA );
1696     if (handle == INVALID_HANDLE_VALUE) return handle;
1697
1698     switch(fInfoLevelId)
1699     {
1700       case FindExInfoStandard:
1701         {
1702           WIN32_FIND_DATAW *dataW = (WIN32_FIND_DATAW*) lpFindFileData;
1703           dataW->dwFileAttributes = dataA.dwFileAttributes;
1704           dataW->ftCreationTime   = dataA.ftCreationTime;
1705           dataW->ftLastAccessTime = dataA.ftLastAccessTime;
1706           dataW->ftLastWriteTime  = dataA.ftLastWriteTime;
1707           dataW->nFileSizeHigh    = dataA.nFileSizeHigh;
1708           dataW->nFileSizeLow     = dataA.nFileSizeLow;
1709           MultiByteToWideChar( CP_ACP, 0, dataA.cFileName, -1,
1710                                dataW->cFileName, sizeof(dataW->cFileName)/sizeof(WCHAR) );
1711           MultiByteToWideChar( CP_ACP, 0, dataA.cAlternateFileName, -1,
1712                                dataW->cAlternateFileName,
1713                                sizeof(dataW->cAlternateFileName)/sizeof(WCHAR) );
1714         }
1715         break;
1716       default:
1717         FIXME("fInfoLevelId 0x%08x not implemented\n", fInfoLevelId );
1718         return INVALID_HANDLE_VALUE;
1719     }
1720     return handle;
1721 }
1722
1723 /*************************************************************************
1724  *           FindFirstFileW   (KERNEL32.@)
1725  */
1726 HANDLE WINAPI FindFirstFileW( LPCWSTR lpFileName, WIN32_FIND_DATAW *lpFindData )
1727 {
1728     return FindFirstFileExW(lpFileName, FindExInfoStandard, lpFindData,
1729                             FindExSearchNameMatch, NULL, 0);
1730 }
1731
1732 /*************************************************************************
1733  *           FindNextFileA   (KERNEL32.@)
1734  */
1735 BOOL WINAPI FindNextFileA( HANDLE handle, WIN32_FIND_DATAA *data )
1736 {
1737     FIND_FIRST_INFO *info;
1738
1739     if ((handle == INVALID_HANDLE_VALUE) ||
1740        !(info = (FIND_FIRST_INFO *)GlobalLock( handle )))
1741     {
1742         SetLastError( ERROR_INVALID_HANDLE );
1743         return FALSE;
1744     }
1745     GlobalUnlock( handle );
1746     if (!info->path || !info->dir)
1747     {
1748         SetLastError( ERROR_NO_MORE_FILES );
1749         return FALSE;
1750     }
1751     if (!DOSFS_FindNextEx( info, data ))
1752     {
1753         DOSFS_CloseDir( info->dir ); info->dir = NULL;
1754         HeapFree( GetProcessHeap(), 0, info->path );
1755         info->path = info->long_mask = NULL;
1756         SetLastError( ERROR_NO_MORE_FILES );
1757         return FALSE;
1758     }
1759     return TRUE;
1760 }
1761
1762
1763 /*************************************************************************
1764  *           FindNextFileW   (KERNEL32.@)
1765  */
1766 BOOL WINAPI FindNextFileW( HANDLE handle, WIN32_FIND_DATAW *data )
1767 {
1768     WIN32_FIND_DATAA dataA;
1769     if (!FindNextFileA( handle, &dataA )) return FALSE;
1770     data->dwFileAttributes = dataA.dwFileAttributes;
1771     data->ftCreationTime   = dataA.ftCreationTime;
1772     data->ftLastAccessTime = dataA.ftLastAccessTime;
1773     data->ftLastWriteTime  = dataA.ftLastWriteTime;
1774     data->nFileSizeHigh    = dataA.nFileSizeHigh;
1775     data->nFileSizeLow     = dataA.nFileSizeLow;
1776     MultiByteToWideChar( CP_ACP, 0, dataA.cFileName, -1,
1777                          data->cFileName, sizeof(data->cFileName)/sizeof(WCHAR) );
1778     MultiByteToWideChar( CP_ACP, 0, dataA.cAlternateFileName, -1,
1779                          data->cAlternateFileName,
1780                          sizeof(data->cAlternateFileName)/sizeof(WCHAR) );
1781     return TRUE;
1782 }
1783
1784 /*************************************************************************
1785  *           FindClose   (KERNEL32.@)
1786  */
1787 BOOL WINAPI FindClose( HANDLE handle )
1788 {
1789     FIND_FIRST_INFO *info;
1790
1791     if ((handle == INVALID_HANDLE_VALUE) ||
1792         !(info = (FIND_FIRST_INFO *)GlobalLock( handle )))
1793     {
1794         SetLastError( ERROR_INVALID_HANDLE );
1795         return FALSE;
1796     }
1797     __TRY
1798     {
1799         if (info->dir) DOSFS_CloseDir( info->dir );
1800         if (info->path) HeapFree( GetProcessHeap(), 0, info->path );
1801     }
1802     __EXCEPT(page_fault)
1803     {
1804         WARN("Illegal handle %x\n", handle);
1805         SetLastError( ERROR_INVALID_HANDLE );
1806         return FALSE;
1807     }
1808     __ENDTRY
1809     GlobalUnlock( handle );
1810     GlobalFree( handle );
1811     return TRUE;
1812 }
1813
1814 /***********************************************************************
1815  *           DOSFS_UnixTimeToFileTime
1816  *
1817  * Convert a Unix time to FILETIME format.
1818  * The FILETIME structure is a 64-bit value representing the number of
1819  * 100-nanosecond intervals since January 1, 1601, 0:00.
1820  * 'remainder' is the nonnegative number of 100-ns intervals
1821  * corresponding to the time fraction smaller than 1 second that
1822  * couldn't be stored in the time_t value.
1823  */
1824 void DOSFS_UnixTimeToFileTime( time_t unix_time, FILETIME *filetime,
1825                                DWORD remainder )
1826 {
1827     /* NOTES:
1828
1829        CONSTANTS:
1830        The time difference between 1 January 1601, 00:00:00 and
1831        1 January 1970, 00:00:00 is 369 years, plus the leap years
1832        from 1604 to 1968, excluding 1700, 1800, 1900.
1833        This makes (1968 - 1600) / 4 - 3 = 89 leap days, and a total
1834        of 134774 days.
1835
1836        Any day in that period had 24 * 60 * 60 = 86400 seconds.
1837
1838        The time difference is 134774 * 86400 * 10000000, which can be written
1839        116444736000000000
1840        27111902 * 2^32 + 3577643008
1841        413 * 2^48 + 45534 * 2^32 + 54590 * 2^16 + 32768
1842
1843        If you find that these constants are buggy, please change them in all
1844        instances in both conversion functions.
1845
1846        VERSIONS:
1847        There are two versions, one of them uses long long variables and
1848        is presumably faster but not ISO C. The other one uses standard C
1849        data types and operations but relies on the assumption that negative
1850        numbers are stored as 2's complement (-1 is 0xffff....). If this
1851        assumption is violated, dates before 1970 will not convert correctly.
1852        This should however work on any reasonable architecture where WINE
1853        will run.
1854
1855        DETAILS:
1856
1857        Take care not to remove the casts. I have tested these functions
1858        (in both versions) for a lot of numbers. I would be interested in
1859        results on other compilers than GCC.
1860
1861        The operations have been designed to account for the possibility
1862        of 64-bit time_t in future UNICES. Even the versions without
1863        internal long long numbers will work if time_t only is 64 bit.
1864        A 32-bit shift, which was necessary for that operation, turned out
1865        not to work correctly in GCC, besides giving the warning. So I
1866        used a double 16-bit shift instead. Numbers are in the ISO version
1867        represented by three limbs, the most significant with 32 bit, the
1868        other two with 16 bit each.
1869
1870        As the modulo-operator % is not well-defined for negative numbers,
1871        negative divisors have been avoided in DOSFS_FileTimeToUnixTime.
1872
1873        There might be quicker ways to do this in C. Certainly so in
1874        assembler.
1875
1876        Claus Fischer, fischer@iue.tuwien.ac.at
1877        */
1878
1879 #if SIZEOF_LONG_LONG >= 8
1880 #  define USE_LONG_LONG 1
1881 #else
1882 #  define USE_LONG_LONG 0
1883 #endif
1884
1885 #if USE_LONG_LONG               /* gcc supports long long type */
1886
1887     long long int t = unix_time;
1888     t *= 10000000;
1889     t += 116444736000000000LL;
1890     t += remainder;
1891     filetime->dwLowDateTime  = (UINT)t;
1892     filetime->dwHighDateTime = (UINT)(t >> 32);
1893
1894 #else  /* ISO version */
1895
1896     UINT a0;                    /* 16 bit, low    bits */
1897     UINT a1;                    /* 16 bit, medium bits */
1898     UINT a2;                    /* 32 bit, high   bits */
1899
1900     /* Copy the unix time to a2/a1/a0 */
1901     a0 =  unix_time & 0xffff;
1902     a1 = (unix_time >> 16) & 0xffff;
1903     /* This is obsolete if unix_time is only 32 bits, but it does not hurt.
1904        Do not replace this by >> 32, it gives a compiler warning and it does
1905        not work. */
1906     a2 = (unix_time >= 0 ? (unix_time >> 16) >> 16 :
1907           ~((~unix_time >> 16) >> 16));
1908
1909     /* Multiply a by 10000000 (a = a2/a1/a0)
1910        Split the factor into 10000 * 1000 which are both less than 0xffff. */
1911     a0 *= 10000;
1912     a1 = a1 * 10000 + (a0 >> 16);
1913     a2 = a2 * 10000 + (a1 >> 16);
1914     a0 &= 0xffff;
1915     a1 &= 0xffff;
1916
1917     a0 *= 1000;
1918     a1 = a1 * 1000 + (a0 >> 16);
1919     a2 = a2 * 1000 + (a1 >> 16);
1920     a0 &= 0xffff;
1921     a1 &= 0xffff;
1922
1923     /* Add the time difference and the remainder */
1924     a0 += 32768 + (remainder & 0xffff);
1925     a1 += 54590 + (remainder >> 16   ) + (a0 >> 16);
1926     a2 += 27111902                     + (a1 >> 16);
1927     a0 &= 0xffff;
1928     a1 &= 0xffff;
1929
1930     /* Set filetime */
1931     filetime->dwLowDateTime  = (a1 << 16) + a0;
1932     filetime->dwHighDateTime = a2;
1933 #endif
1934 }
1935
1936
1937 /***********************************************************************
1938  *           DOSFS_FileTimeToUnixTime
1939  *
1940  * Convert a FILETIME format to Unix time.
1941  * If not NULL, 'remainder' contains the fractional part of the filetime,
1942  * in the range of [0..9999999] (even if time_t is negative).
1943  */
1944 time_t DOSFS_FileTimeToUnixTime( const FILETIME *filetime, DWORD *remainder )
1945 {
1946     /* Read the comment in the function DOSFS_UnixTimeToFileTime. */
1947 #if USE_LONG_LONG
1948
1949     long long int t = filetime->dwHighDateTime;
1950     t <<= 32;
1951     t += (UINT)filetime->dwLowDateTime;
1952     t -= 116444736000000000LL;
1953     if (t < 0)
1954     {
1955         if (remainder) *remainder = 9999999 - (-t - 1) % 10000000;
1956         return -1 - ((-t - 1) / 10000000);
1957     }
1958     else
1959     {
1960         if (remainder) *remainder = t % 10000000;
1961         return t / 10000000;
1962     }
1963
1964 #else  /* ISO version */
1965
1966     UINT a0;                    /* 16 bit, low    bits */
1967     UINT a1;                    /* 16 bit, medium bits */
1968     UINT a2;                    /* 32 bit, high   bits */
1969     UINT r;                     /* remainder of division */
1970     unsigned int carry;         /* carry bit for subtraction */
1971     int negative;               /* whether a represents a negative value */
1972
1973     /* Copy the time values to a2/a1/a0 */
1974     a2 =  (UINT)filetime->dwHighDateTime;
1975     a1 = ((UINT)filetime->dwLowDateTime ) >> 16;
1976     a0 = ((UINT)filetime->dwLowDateTime ) & 0xffff;
1977
1978     /* Subtract the time difference */
1979     if (a0 >= 32768           ) a0 -=             32768        , carry = 0;
1980     else                        a0 += (1 << 16) - 32768        , carry = 1;
1981
1982     if (a1 >= 54590    + carry) a1 -=             54590 + carry, carry = 0;
1983     else                        a1 += (1 << 16) - 54590 - carry, carry = 1;
1984
1985     a2 -= 27111902 + carry;
1986
1987     /* If a is negative, replace a by (-1-a) */
1988     negative = (a2 >= ((UINT)1) << 31);
1989     if (negative)
1990     {
1991         /* Set a to -a - 1 (a is a2/a1/a0) */
1992         a0 = 0xffff - a0;
1993         a1 = 0xffff - a1;
1994         a2 = ~a2;
1995     }
1996
1997     /* Divide a by 10000000 (a = a2/a1/a0), put the rest into r.
1998        Split the divisor into 10000 * 1000 which are both less than 0xffff. */
1999     a1 += (a2 % 10000) << 16;
2000     a2 /=       10000;
2001     a0 += (a1 % 10000) << 16;
2002     a1 /=       10000;
2003     r   =  a0 % 10000;
2004     a0 /=       10000;
2005
2006     a1 += (a2 % 1000) << 16;
2007     a2 /=       1000;
2008     a0 += (a1 % 1000) << 16;
2009     a1 /=       1000;
2010     r  += (a0 % 1000) * 10000;
2011     a0 /=       1000;
2012
2013     /* If a was negative, replace a by (-1-a) and r by (9999999 - r) */
2014     if (negative)
2015     {
2016         /* Set a to -a - 1 (a is a2/a1/a0) */
2017         a0 = 0xffff - a0;
2018         a1 = 0xffff - a1;
2019         a2 = ~a2;
2020
2021         r  = 9999999 - r;
2022     }
2023
2024     if (remainder) *remainder = r;
2025
2026     /* Do not replace this by << 32, it gives a compiler warning and it does
2027        not work. */
2028     return ((((time_t)a2) << 16) << 16) + (a1 << 16) + a0;
2029 #endif
2030 }
2031
2032
2033 /***********************************************************************
2034  *           MulDiv   (KERNEL32.@)
2035  * RETURNS
2036  *      Result of multiplication and division
2037  *      -1: Overflow occurred or Divisor was 0
2038  */
2039 INT WINAPI MulDiv(
2040              INT nMultiplicand,
2041              INT nMultiplier,
2042              INT nDivisor)
2043 {
2044 #if SIZEOF_LONG_LONG >= 8
2045     long long ret;
2046
2047     if (!nDivisor) return -1;
2048
2049     /* We want to deal with a positive divisor to simplify the logic. */
2050     if (nDivisor < 0)
2051     {
2052       nMultiplicand = - nMultiplicand;
2053       nDivisor = -nDivisor;
2054     }
2055
2056     /* If the result is positive, we "add" to round. else, we subtract to round. */
2057     if ( ( (nMultiplicand <  0) && (nMultiplier <  0) ) ||
2058          ( (nMultiplicand >= 0) && (nMultiplier >= 0) ) )
2059       ret = (((long long)nMultiplicand * nMultiplier) + (nDivisor/2)) / nDivisor;
2060     else
2061       ret = (((long long)nMultiplicand * nMultiplier) - (nDivisor/2)) / nDivisor;
2062
2063     if ((ret > 2147483647) || (ret < -2147483647)) return -1;
2064     return ret;
2065 #else
2066     if (!nDivisor) return -1;
2067
2068     /* We want to deal with a positive divisor to simplify the logic. */
2069     if (nDivisor < 0)
2070     {
2071       nMultiplicand = - nMultiplicand;
2072       nDivisor = -nDivisor;
2073     }
2074
2075     /* If the result is positive, we "add" to round. else, we subtract to round. */
2076     if ( ( (nMultiplicand <  0) && (nMultiplier <  0) ) ||
2077          ( (nMultiplicand >= 0) && (nMultiplier >= 0) ) )
2078       return ((nMultiplicand * nMultiplier) + (nDivisor/2)) / nDivisor;
2079
2080     return ((nMultiplicand * nMultiplier) - (nDivisor/2)) / nDivisor;
2081
2082 #endif
2083 }
2084
2085
2086 /***********************************************************************
2087  *           DosDateTimeToFileTime   (KERNEL32.@)
2088  */
2089 BOOL WINAPI DosDateTimeToFileTime( WORD fatdate, WORD fattime, LPFILETIME ft)
2090 {
2091     struct tm newtm;
2092
2093     newtm.tm_sec  = (fattime & 0x1f) * 2;
2094     newtm.tm_min  = (fattime >> 5) & 0x3f;
2095     newtm.tm_hour = (fattime >> 11);
2096     newtm.tm_mday = (fatdate & 0x1f);
2097     newtm.tm_mon  = ((fatdate >> 5) & 0x0f) - 1;
2098     newtm.tm_year = (fatdate >> 9) + 80;
2099     RtlSecondsSince1970ToTime( mktime( &newtm ), ft );
2100     return TRUE;
2101 }
2102
2103
2104 /***********************************************************************
2105  *           FileTimeToDosDateTime   (KERNEL32.@)
2106  */
2107 BOOL WINAPI FileTimeToDosDateTime( const FILETIME *ft, LPWORD fatdate,
2108                                      LPWORD fattime )
2109 {
2110     time_t unixtime = DOSFS_FileTimeToUnixTime( ft, NULL );
2111     struct tm *tm = localtime( &unixtime );
2112     if (fattime)
2113         *fattime = (tm->tm_hour << 11) + (tm->tm_min << 5) + (tm->tm_sec / 2);
2114     if (fatdate)
2115         *fatdate = ((tm->tm_year - 80) << 9) + ((tm->tm_mon + 1) << 5)
2116                    + tm->tm_mday;
2117     return TRUE;
2118 }
2119
2120
2121 /***********************************************************************
2122  *           LocalFileTimeToFileTime   (KERNEL32.@)
2123  */
2124 BOOL WINAPI LocalFileTimeToFileTime( const FILETIME *localft,
2125                                        LPFILETIME utcft )
2126 {
2127     struct tm *xtm;
2128     DWORD remainder;
2129
2130     /* convert from local to UTC. Perhaps not correct. FIXME */
2131     time_t unixtime = DOSFS_FileTimeToUnixTime( localft, &remainder );
2132     xtm = gmtime( &unixtime );
2133     DOSFS_UnixTimeToFileTime( mktime(xtm), utcft, remainder );
2134     return TRUE;
2135 }
2136
2137
2138 /***********************************************************************
2139  *           FileTimeToLocalFileTime   (KERNEL32.@)
2140  */
2141 BOOL WINAPI FileTimeToLocalFileTime( const FILETIME *utcft,
2142                                        LPFILETIME localft )
2143 {
2144     DWORD remainder;
2145     /* convert from UTC to local. Perhaps not correct. FIXME */
2146     time_t unixtime = DOSFS_FileTimeToUnixTime( utcft, &remainder );
2147 #ifdef HAVE_TIMEGM
2148     struct tm *xtm = localtime( &unixtime );
2149     time_t localtime;
2150
2151     localtime = timegm(xtm);
2152     DOSFS_UnixTimeToFileTime( localtime, localft, remainder );
2153
2154 #else
2155     struct tm *xtm,*gtm;
2156     time_t time1,time2;
2157
2158     xtm = localtime( &unixtime );
2159     gtm = gmtime( &unixtime );
2160     time1 = mktime(xtm);
2161     time2 = mktime(gtm);
2162     DOSFS_UnixTimeToFileTime( 2*time1-time2, localft, remainder );
2163 #endif
2164     return TRUE;
2165 }
2166
2167
2168 /***********************************************************************
2169  *           FileTimeToSystemTime   (KERNEL32.@)
2170  */
2171 BOOL WINAPI FileTimeToSystemTime( const FILETIME *ft, LPSYSTEMTIME syst )
2172 {
2173     struct tm *xtm;
2174     DWORD remainder;
2175     time_t xtime = DOSFS_FileTimeToUnixTime( ft, &remainder );
2176     xtm = gmtime(&xtime);
2177     syst->wYear         = xtm->tm_year+1900;
2178     syst->wMonth        = xtm->tm_mon + 1;
2179     syst->wDayOfWeek    = xtm->tm_wday;
2180     syst->wDay          = xtm->tm_mday;
2181     syst->wHour         = xtm->tm_hour;
2182     syst->wMinute       = xtm->tm_min;
2183     syst->wSecond       = xtm->tm_sec;
2184     syst->wMilliseconds = remainder / 10000;
2185     return TRUE;
2186 }
2187
2188 /***********************************************************************
2189  *           QueryDosDeviceA   (KERNEL32.@)
2190  *
2191  * returns array of strings terminated by \0, terminated by \0
2192  */
2193 DWORD WINAPI QueryDosDeviceA(LPCSTR devname,LPSTR target,DWORD bufsize)
2194 {
2195     LPSTR s;
2196     char  buffer[200];
2197
2198     TRACE("(%s,...)\n", devname ? devname : "<null>");
2199     if (!devname) {
2200         /* return known MSDOS devices */
2201         static const char devices[24] = "CON\0COM1\0COM2\0LPT1\0NUL\0\0";
2202         memcpy( target, devices, min(bufsize,sizeof(devices)) );
2203         return min(bufsize,sizeof(devices));
2204     }
2205     /* In theory all that are possible and have been defined.
2206      * Now just those below, since mirc uses it to check for special files.
2207      *
2208      * (It is more complex, and supports netmounted stuff, and \\.\ stuff,
2209      *  but currently we just ignore that.)
2210      */
2211 #define CHECK(x) (strstr(devname,#x)==devname)
2212     if (CHECK(con) || CHECK(com) || CHECK(lpt) || CHECK(nul)) {
2213         strcpy(buffer,"\\DEV\\");
2214         strcat(buffer,devname);
2215         if ((s=strchr(buffer,':'))) *s='\0';
2216         lstrcpynA(target,buffer,bufsize);
2217         return strlen(buffer)+1;
2218     } else {
2219         if (strchr(devname,':') || devname[0]=='\\') {
2220             /* This might be a DOS device we do not handle yet ... */
2221             FIXME("(%s) not detected as DOS device!\n",devname);
2222         }
2223         SetLastError(ERROR_DEV_NOT_EXIST);
2224         return 0;
2225     }
2226
2227 }
2228
2229
2230 /***********************************************************************
2231  *           QueryDosDeviceW   (KERNEL32.@)
2232  *
2233  * returns array of strings terminated by \0, terminated by \0
2234  */
2235 DWORD WINAPI QueryDosDeviceW(LPCWSTR devname,LPWSTR target,DWORD bufsize)
2236 {
2237     LPSTR devnameA = devname?HEAP_strdupWtoA(GetProcessHeap(),0,devname):NULL;
2238     LPSTR targetA = (LPSTR)HeapAlloc(GetProcessHeap(),0,bufsize);
2239     DWORD ret = QueryDosDeviceA(devnameA,targetA,bufsize);
2240
2241     ret = MultiByteToWideChar( CP_ACP, 0, targetA, ret, target, bufsize );
2242     if (devnameA) HeapFree(GetProcessHeap(),0,devnameA);
2243     if (targetA) HeapFree(GetProcessHeap(),0,targetA);
2244     return ret;
2245 }
2246
2247
2248 /***********************************************************************
2249  *           SystemTimeToFileTime   (KERNEL32.@)
2250  */
2251 BOOL WINAPI SystemTimeToFileTime( const SYSTEMTIME *syst, LPFILETIME ft )
2252 {
2253 #ifdef HAVE_TIMEGM
2254     struct tm xtm;
2255     time_t utctime;
2256 #else
2257     struct tm xtm,*local_tm,*utc_tm;
2258     time_t localtim,utctime;
2259 #endif
2260
2261     xtm.tm_year = syst->wYear-1900;
2262     xtm.tm_mon  = syst->wMonth - 1;
2263     xtm.tm_wday = syst->wDayOfWeek;
2264     xtm.tm_mday = syst->wDay;
2265     xtm.tm_hour = syst->wHour;
2266     xtm.tm_min  = syst->wMinute;
2267     xtm.tm_sec  = syst->wSecond; /* this is UTC */
2268     xtm.tm_isdst = -1;
2269 #ifdef HAVE_TIMEGM
2270     utctime = timegm(&xtm);
2271     DOSFS_UnixTimeToFileTime( utctime, ft,
2272                               syst->wMilliseconds * 10000 );
2273 #else
2274     localtim = mktime(&xtm);    /* now we've got local time */
2275     local_tm = localtime(&localtim);
2276     utc_tm = gmtime(&localtim);
2277     utctime = mktime(utc_tm);
2278     DOSFS_UnixTimeToFileTime( 2*localtim -utctime, ft,
2279                               syst->wMilliseconds * 10000 );
2280 #endif
2281     return TRUE;
2282 }
2283
2284 /***********************************************************************
2285  *           DefineDosDeviceA       (KERNEL32.@)
2286  */
2287 BOOL WINAPI DefineDosDeviceA(DWORD flags,LPCSTR devname,LPCSTR targetpath) {
2288         FIXME("(0x%08lx,%s,%s),stub!\n",flags,devname,targetpath);
2289         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2290         return FALSE;
2291 }
2292
2293 /*
2294    --- 16 bit functions ---
2295 */
2296
2297 /*************************************************************************
2298  *           FindFirstFile   (KERNEL.413)
2299  */
2300 HANDLE16 WINAPI FindFirstFile16( LPCSTR path, WIN32_FIND_DATAA *data )
2301 {
2302     DOS_FULL_NAME full_name;
2303     HGLOBAL16 handle;
2304     FIND_FIRST_INFO *info;
2305
2306     data->dwReserved0 = data->dwReserved1 = 0x0;
2307     if (!path) return 0;
2308     if (!DOSFS_GetFullName( path, FALSE, &full_name ))
2309         return INVALID_HANDLE_VALUE16;
2310     if (!(handle = GlobalAlloc16( GMEM_MOVEABLE, sizeof(FIND_FIRST_INFO) )))
2311         return INVALID_HANDLE_VALUE16;
2312     info = (FIND_FIRST_INFO *)GlobalLock16( handle );
2313     info->path = HeapAlloc( GetProcessHeap(), 0, strlen(full_name.long_name)+1 );
2314     strcpy( info->path, full_name.long_name );
2315     info->long_mask = strrchr( info->path, '/' );
2316     if (info->long_mask )
2317         *(info->long_mask++) = '\0';
2318     info->short_mask = NULL;
2319     info->attr = 0xff;
2320     if (path[0] && (path[1] == ':')) info->drive = FILE_toupper(*path) - 'A';
2321     else info->drive = DRIVE_GetCurrentDrive();
2322     info->cur_pos = 0;
2323
2324     info->dir = DOSFS_OpenDir( info->path );
2325
2326     GlobalUnlock16( handle );
2327     if (!FindNextFile16( handle, data ))
2328     {
2329         FindClose16( handle );
2330         SetLastError( ERROR_NO_MORE_FILES );
2331         return INVALID_HANDLE_VALUE16;
2332     }
2333     return handle;
2334 }
2335
2336 /*************************************************************************
2337  *           FindNextFile   (KERNEL.414)
2338  */
2339 BOOL16 WINAPI FindNextFile16( HANDLE16 handle, WIN32_FIND_DATAA *data )
2340 {
2341     FIND_FIRST_INFO *info;
2342
2343     if ((handle == INVALID_HANDLE_VALUE16) ||
2344        !(info = (FIND_FIRST_INFO *)GlobalLock16( handle )))
2345     {
2346         SetLastError( ERROR_INVALID_HANDLE );
2347         return FALSE;
2348     }
2349     GlobalUnlock16( handle );
2350     if (!info->path || !info->dir)
2351     {
2352         SetLastError( ERROR_NO_MORE_FILES );
2353         return FALSE;
2354     }
2355     if (!DOSFS_FindNextEx( info, data ))
2356     {
2357         DOSFS_CloseDir( info->dir ); info->dir = NULL;
2358         HeapFree( GetProcessHeap(), 0, info->path );
2359         info->path = info->long_mask = NULL;
2360         SetLastError( ERROR_NO_MORE_FILES );
2361         return FALSE;
2362     }
2363     return TRUE;
2364 }
2365
2366 /*************************************************************************
2367  *           FindClose   (KERNEL.415)
2368  */
2369 BOOL16 WINAPI FindClose16( HANDLE16 handle )
2370 {
2371     FIND_FIRST_INFO *info;
2372
2373     if ((handle == INVALID_HANDLE_VALUE16) ||
2374         !(info = (FIND_FIRST_INFO *)GlobalLock16( handle )))
2375     {
2376         SetLastError( ERROR_INVALID_HANDLE );
2377         return FALSE;
2378     }
2379     if (info->dir) DOSFS_CloseDir( info->dir );
2380     if (info->path) HeapFree( GetProcessHeap(), 0, info->path );
2381     GlobalUnlock16( handle );
2382     GlobalFree16( handle );
2383     return TRUE;
2384 }
2385