files/dos_fs.c

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