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