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