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 "wingdi.h"
  26 #include "winuser.h"
  27 #include "wine/winbase16.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 "process.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 */
 534     while (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     struct get_file_info_request *req = get_req_buffer();
 626
 627     req->handle = hFile;
 628     if (!server_call( REQ_GET_FILE_INFO ) && (req->type == FILE_TYPE_UNKNOWN))
 629     {
 630         if ((req->attr >= 0) &&
 631             (req->attr < sizeof(DOSFS_Devices)/sizeof(DOSFS_Devices[0])))
 632             return &DOSFS_Devices[req->attr];
 633     }
 634     return NULL;
 635 }
 636
 637
 638 /***********************************************************************
 639  *           DOSFS_OpenDevice
 640  *
 641  * Open a DOS device. This might not map 1:1 into the UNIX device concept.
 642  */
 643 HFILE DOSFS_OpenDevice( const char *name, DWORD access )
 644 {
 645     int i;
 646     const char *p;
 647
 648     if (!name) return (HFILE)NULL; /* if FILE_DupUnixHandle was used */
 649     if (name[0] && (name[1] == ':')) name += 2;
 650     if ((p = strrchr( name, '/' ))) name = p + 1;
 651     if ((p = strrchr( name, '\\' ))) name = p + 1;
 652     for (i = 0; i < sizeof(DOSFS_Devices)/sizeof(DOSFS_Devices[0]); i++)
 653     {
 654         const char *dev = DOSFS_Devices[i].name;
 655         if (!lstrncmpiA( dev, name, strlen(dev) ))
 656         {
 657             p = name + strlen( dev );
 658             if (!*p || (*p == '.')) {
 659                 /* got it */
 660                 if (!strcmp(DOSFS_Devices[i].name,"NUL"))
 661                     return FILE_CreateFile( "/dev/null", access,
 662                                             FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
 663                                             OPEN_EXISTING, 0, -1 );
 664                 if (!strcmp(DOSFS_Devices[i].name,"CON")) {
 665                         HFILE to_dup;
 666                         HFILE handle;
 667                         switch (access & (GENERIC_READ|GENERIC_WRITE)) {
 668                         case GENERIC_READ:
 669                                 to_dup = GetStdHandle( STD_INPUT_HANDLE );
 670                                 break;
 671                         case GENERIC_WRITE:
 672                                 to_dup = GetStdHandle( STD_OUTPUT_HANDLE );
 673                                 break;
 674                         default:
 675                                 FIXME("can't open CON read/write\n");
 676                                 return HFILE_ERROR;
 677                                 break;
 678                         }
 679                         if (!DuplicateHandle( GetCurrentProcess(), to_dup, GetCurrentProcess(),
 680                                               &handle, 0, FALSE, DUPLICATE_SAME_ACCESS ))
 681                             handle = HFILE_ERROR;
 682                         return handle;
 683                 }
 684                 if (!strcmp(DOSFS_Devices[i].name,"SCSIMGR$") ||
 685                     !strcmp(DOSFS_Devices[i].name,"HPSCAN"))
 686                 {
 687                     return FILE_CreateDevice( i, access, NULL );
 688                 }
 689                 {
 690                     HFILE r;
 691                     char devname[40];
 692                     PROFILE_GetWineIniString("serialports",name,"",devname,sizeof devname);
 693
 694                     if(devname[0])
 695                     {
 696                         TRACE_(file)("DOSFS_OpenDevice %s is %s\n",
 697                                      DOSFS_Devices[i].name,devname);
 698                         r =  FILE_CreateFile( devname, access,
 699                                 FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
 700                                 OPEN_EXISTING, 0, -1 );
 701                         TRACE_(file)("Create_File return %08X\n",r);
 702                         return r;
 703                     }
 704                 }
 705
 706                 FIXME("device open %s not supported (yet)\n",DOSFS_Devices[i].name);
 707                 return HFILE_ERROR;
 708             }
 709         }
 710     }
 711     return HFILE_ERROR;
 712 }
 713
 714
 715 /***********************************************************************
 716  *           DOSFS_GetPathDrive
 717  *
 718  * Get the drive specified by a given path name (DOS or Unix format).
 719  */
 720 static int DOSFS_GetPathDrive( const char **name )
 721 {
 722     int drive;
 723     const char *p = *name;
 724
 725     if (*p && (p[1] == ':'))
 726     {
 727         drive = toupper(*p) - 'A';
 728         *name += 2;
 729     }
 730     else if (*p == '/') /* Absolute Unix path? */
 731     {
 732         if ((drive = DRIVE_FindDriveRoot( name )) == -1)
 733         {
 734             MESSAGE("Warning: %s not accessible from a DOS drive\n", *name );
 735             /* Assume it really was a DOS name */
 736             drive = DRIVE_GetCurrentDrive();
 737         }
 738     }
 739     else drive = DRIVE_GetCurrentDrive();
 740
 741     if (!DRIVE_IsValid(drive))
 742     {
 743         SetLastError( ERROR_INVALID_DRIVE );
 744         return -1;
 745     }
 746     return drive;
 747 }
 748
 749
 750 /***********************************************************************
 751  *           DOSFS_GetFullName
 752  *
 753  * Convert a file name (DOS or mixed DOS/Unix format) to a valid
 754  * Unix name / short DOS name pair.
 755  * Return FALSE if one of the path components does not exist. The last path
 756  * component is only checked if 'check_last' is non-zero.
 757  * The buffers pointed to by 'long_buf' and 'short_buf' must be
 758  * at least MAX_PATHNAME_LEN long.
 759  */
 760 BOOL DOSFS_GetFullName( LPCSTR name, BOOL check_last, DOS_FULL_NAME *full )
 761 {
 762     BOOL found;
 763     UINT flags;
 764     char *p_l, *p_s, *root;
 765
 766     TRACE("%s (last=%d)\n", name, check_last );
 767
 768     if ((full->drive = DOSFS_GetPathDrive( &name )) == -1) return FALSE;
 769     flags = DRIVE_GetFlags( full->drive );
 770
 771     lstrcpynA( full->long_name, DRIVE_GetRoot( full->drive ),
 772                  sizeof(full->long_name) );
 773     if (full->long_name[1]) root = full->long_name + strlen(full->long_name);
 774     else root = full->long_name;  /* root directory */
 775
 776     strcpy( full->short_name, "A:\\" );
 777     full->short_name[0] += full->drive;
 778
 779     if ((*name == '\\') || (*name == '/'))  /* Absolute path */
 780     {
 781         while ((*name == '\\') || (*name == '/')) name++;
 782     }
 783     else  /* Relative path */
 784     {
 785         lstrcpynA( root + 1, DRIVE_GetUnixCwd( full->drive ),
 786                      sizeof(full->long_name) - (root - full->long_name) - 1 );
 787         if (root[1]) *root = '/';
 788         lstrcpynA( full->short_name + 3, DRIVE_GetDosCwd( full->drive ),
 789                      sizeof(full->short_name) - 3 );
 790     }
 791
 792     p_l = full->long_name[1] ? full->long_name + strlen(full->long_name)
 793                              : full->long_name;
 794     p_s = full->short_name[3] ? full->short_name + strlen(full->short_name)
 795                               : full->short_name + 2;
 796     found = TRUE;
 797
 798     while (*name && found)
 799     {
 800         /* Check for '.' and '..' */
 801
 802         if (*name == '.')
 803         {
 804             if (IS_END_OF_NAME(name[1]))
 805             {
 806                 name++;
 807                 while ((*name == '\\') || (*name == '/')) name++;
 808                 continue;
 809             }
 810             else if ((name[1] == '.') && IS_END_OF_NAME(name[2]))
 811             {
 812                 name += 2;
 813                 while ((*name == '\\') || (*name == '/')) name++;
 814                 while ((p_l > root) && (*p_l != '/')) p_l--;
 815                 while ((p_s > full->short_name + 2) && (*p_s != '\\')) p_s--;
 816                 *p_l = *p_s = '\0';  /* Remove trailing separator */
 817                 continue;
 818             }
 819         }
 820
 821         /* Make sure buffers are large enough */
 822
 823         if ((p_s >= full->short_name + sizeof(full->short_name) - 14) ||
 824             (p_l >= full->long_name + sizeof(full->long_name) - 1))
 825         {
 826             SetLastError( ERROR_PATH_NOT_FOUND );
 827             return FALSE;
 828         }
 829
 830         /* Get the long and short name matching the file name */
 831
 832         if ((found = DOSFS_FindUnixName( full->long_name, name, p_l + 1,
 833                          sizeof(full->long_name) - (p_l - full->long_name) - 1,
 834                          p_s + 1, !(flags & DRIVE_CASE_SENSITIVE) )))
 835         {
 836             *p_l++ = '/';
 837             p_l   += strlen(p_l);
 838             *p_s++ = '\\';
 839             p_s   += strlen(p_s);
 840             while (!IS_END_OF_NAME(*name)) name++;
 841         }
 842         else if (!check_last)
 843         {
 844             *p_l++ = '/';
 845             *p_s++ = '\\';
 846             while (!IS_END_OF_NAME(*name) &&
 847                    (p_s < full->short_name + sizeof(full->short_name) - 1) &&
 848                    (p_l < full->long_name + sizeof(full->long_name) - 1))
 849             {
 850                 *p_s++ = tolower(*name);
 851                 /* If the drive is case-sensitive we want to create new */
 852                 /* files in lower-case otherwise we can't reopen them   */
 853                 /* under the same short name. */
 854                 if (flags & DRIVE_CASE_SENSITIVE) *p_l++ = tolower(*name);
 855                 else *p_l++ = *name;
 856                 name++;
 857             }
 858             *p_l = *p_s = '\0';
 859         }
 860         while ((*name == '\\') || (*name == '/')) name++;
 861     }
 862
 863     if (!found)
 864     {
 865         if (check_last)
 866         {
 867             SetLastError( ERROR_FILE_NOT_FOUND );
 868             return FALSE;
 869         }
 870         if (*name)  /* Not last */
 871         {
 872             SetLastError( ERROR_PATH_NOT_FOUND );
 873             return FALSE;
 874         }
 875     }
 876     if (!full->long_name[0]) strcpy( full->long_name, "/" );
 877     if (!full->short_name[2]) strcpy( full->short_name + 2, "\\" );
 878     TRACE("returning %s = %s\n", full->long_name, full->short_name );
 879     return TRUE;
 880 }
 881
 882
 883 /***********************************************************************
 884  *           GetShortPathNameA   (KERNEL32.271)
 885  *
 886  * NOTES
 887  *  observed:
 888  *  longpath=NULL: LastError=ERROR_INVALID_PARAMETER, ret=0
 889  *  *longpath="" or invalid: LastError=ERROR_BAD_PATHNAME, ret=0
 890  *
 891  * more observations ( with NT 3.51 (WinDD) ):
 892  * longpath <= 8.3 -> just copy longpath to shortpath
 893  * longpath > 8.3  ->
 894  *             a) file does not exist -> return 0, LastError = ERROR_FILE_NOT_FOUND
 895  *             b) file does exist     -> set the short filename.
 896  * - trailing slashes are reproduced in the short name, even if the
 897  *   file is not a directory
 898  * - the absolute/relative path of the short name is reproduced like found
 899  *   in the long name
 900  * - longpath and shortpath may have the same adress
 901  * Peter Ganten, 1999
 902  */
 903 DWORD WINAPI GetShortPathNameA( LPCSTR longpath, LPSTR shortpath,
 904                                   DWORD shortlen )
 905 {
 906     DOS_FULL_NAME full_name;
 907     LPSTR tmpshortpath;
 908     DWORD sp = 0, lp = 0;
 909     int tmplen, drive;
 910     UINT flags;
 911
 912     TRACE("%s\n", debugstr_a(longpath));
 913
 914     if (!longpath) {
 915       SetLastError(ERROR_INVALID_PARAMETER);
 916       return 0;
 917     }
 918     if (!longpath[0]) {
 919       SetLastError(ERROR_BAD_PATHNAME);
 920       return 0;
 921     }
 922
 923     if ( ( tmpshortpath = HeapAlloc ( GetProcessHeap(), 0, MAX_PATHNAME_LEN ) ) == NULL ) {
 924       SetLastError ( ERROR_NOT_ENOUGH_MEMORY );
 925       return 0;
 926     }
 927
 928     /* check for drive letter */
 929     if ( longpath[1] == ':' ) {
 930       tmpshortpath[0] = longpath[0];
 931       tmpshortpath[1] = ':';
 932       sp = 2;
 933     }
 934
 935     if ( ( drive = DOSFS_GetPathDrive ( &longpath )) == -1 ) return 0;
 936     flags = DRIVE_GetFlags ( drive );
 937
 938     while ( longpath[lp] ) {
 939
 940       /* check for path delimiters and reproduce them */
 941       if ( longpath[lp] == '\\' || longpath[lp] == '/' ) {
 942         tmpshortpath[sp] = longpath[lp];
 943         sp++;
 944         lp++;
 945         continue;
 946       }
 947
 948       tmplen = strcspn ( longpath + lp, "\\/" );
 949       lstrcpynA ( tmpshortpath+sp, longpath + lp, tmplen+1 );
 950
 951       /* Check, if the current element is a valid dos name */
 952       if ( DOSFS_ValidDOSName ( longpath + lp, !(flags & DRIVE_CASE_SENSITIVE) ) ) {
 953         sp += tmplen;
 954         lp += tmplen;
 955         continue;
 956       }
 957
 958       /* Check if the file exists and use the existing file name */
 959       if ( DOSFS_GetFullName ( tmpshortpath, TRUE, &full_name ) ) {
 960         lstrcpyA ( tmpshortpath+sp, strrchr ( full_name.short_name, '\\' ) + 1 );
 961         sp += lstrlenA ( tmpshortpath+sp );
 962         lp += tmplen;
 963         continue;
 964       }
 965
 966       TRACE("not found!\n" );
 967       SetLastError ( ERROR_FILE_NOT_FOUND );
 968       return 0;
 969     }
 970
 971     lstrcpynA ( shortpath, tmpshortpath, shortlen );
 972     TRACE("returning %s\n", debugstr_a(shortpath) );
 973     tmplen = lstrlenA ( tmpshortpath );
 974     HeapFree ( GetProcessHeap(), 0, tmpshortpath );
 975
 976     return tmplen;
 977 }
 978
 979
 980 /***********************************************************************
 981  *           GetShortPathNameW   (KERNEL32.272)
 982  */
 983 DWORD WINAPI GetShortPathNameW( LPCWSTR longpath, LPWSTR shortpath,
 984                                   DWORD shortlen )
 985 {
 986     LPSTR longpathA, shortpathA;
 987     DWORD ret = 0;
 988
 989     longpathA = HEAP_strdupWtoA( GetProcessHeap(), 0, longpath );
 990     shortpathA = HEAP_xalloc ( GetProcessHeap(), 0, shortlen );
 991
 992     ret = GetShortPathNameA ( longpathA, shortpathA, shortlen );
 993     lstrcpynAtoW ( shortpath, shortpathA, shortlen );
 994
 995     HeapFree( GetProcessHeap(), 0, longpathA );
 996     HeapFree( GetProcessHeap(), 0, shortpathA );
 997
 998     return ret;
 999 }
1000
1001
1002 /***********************************************************************
1003  *           GetLongPathNameA   (KERNEL32.xxx)
1004  */
1005 DWORD WINAPI GetLongPathNameA( LPCSTR shortpath, LPSTR longpath,
1006                                   DWORD longlen )
1007 {
1008     DOS_FULL_NAME full_name;
1009     char *p, *r, *ll, *ss;
1010
1011     if (!DOSFS_GetFullName( shortpath, TRUE, &full_name )) return 0;
1012     lstrcpynA( longpath, full_name.short_name, longlen );
1013
1014     /* Do some hackery to get the long filename. */
1015
1016     if (longpath) {
1017      ss=longpath+strlen(longpath);
1018      ll=full_name.long_name+strlen(full_name.long_name);
1019      p=NULL;
1020      while (ss>=longpath)
1021      {
1022        /* FIXME: aren't we more paranoid, than needed? */
1023        while ((ss[0]=='\\') && (ss>=longpath)) ss--;
1024        p=ss;
1025        while ((ss[0]!='\\') && (ss>=longpath)) ss--;
1026        if (ss>=longpath)
1027          {
1028          /* FIXME: aren't we more paranoid, than needed? */
1029          while ((ll[0]=='/') && (ll>=full_name.long_name)) ll--;
1030          while ((ll[0]!='/') && (ll>=full_name.long_name)) ll--;
1031          if (ll<full_name.long_name)
1032               {
1033               ERR("Bad longname! (ss=%s ll=%s)\n This should never happen !\n"
1034                   ,ss ,ll );
1035               return 0;
1036               }
1037          }
1038      }
1039
1040    /* FIXME: fix for names like "C:\\" (ie. with more '\'s) */
1041       if (p && p[2])
1042         {
1043         p+=1;
1044         if ((p-longpath)>0) longlen -= (p-longpath);
1045         lstrcpynA( p, ll , longlen);
1046
1047         /* Now, change all '/' to '\' */
1048         for (r=p; r<(p+longlen); r++ )
1049           if (r[0]=='/') r[0]='\\';
1050         return strlen(longpath) - strlen(p) + longlen;
1051         }
1052     }
1053
1054     return strlen(longpath);
1055 }
1056
1057
1058 /***********************************************************************
1059  *           GetLongPathNameW   (KERNEL32.269)
1060  */
1061 DWORD WINAPI GetLongPathNameW( LPCWSTR shortpath, LPWSTR longpath,
1062                                   DWORD longlen )
1063 {
1064     DOS_FULL_NAME full_name;
1065     DWORD ret = 0;
1066     LPSTR shortpathA = HEAP_strdupWtoA( GetProcessHeap(), 0, shortpath );
1067
1068     /* FIXME: is it correct to always return a fully qualified short path? */
1069     if (DOSFS_GetFullName( shortpathA, TRUE, &full_name ))
1070     {
1071         ret = strlen( full_name.short_name );
1072         lstrcpynAtoW( longpath, full_name.long_name, longlen );
1073     }
1074     HeapFree( GetProcessHeap(), 0, shortpathA );
1075     return ret;
1076 }
1077
1078
1079 /***********************************************************************
1080  *           DOSFS_DoGetFullPathName
1081  *
1082  * Implementation of GetFullPathNameA/W.
1083  *
1084  * Known discrepancies to Win95 OSR2 bon 000118
1085  * "g:..\test should return G:\test
1086  * "..\..\..\..\test should return (Current drive):test
1087  *              even when test is not existant
1088  */
1089 static DWORD DOSFS_DoGetFullPathName( LPCSTR name, DWORD len, LPSTR result,
1090                                       BOOL unicode )
1091 {
1092     char buffer[MAX_PATHNAME_LEN];
1093     int drive;
1094     char *p;
1095     char namelast;
1096     DWORD ret;
1097
1098     /* Address of the last byte in the buffer */
1099     char *endbuf = buffer + sizeof(buffer) - 1;
1100
1101     TRACE("converting '%s'\n", name );
1102
1103     if (!name || ((drive = DOSFS_GetPathDrive( &name )) == -1) )
1104     {
1105         SetLastError( ERROR_INVALID_PARAMETER );
1106         return 0;
1107     }
1108
1109     p = buffer;
1110     *p++ = 'A' + drive;
1111     *p++ = ':';
1112     *p++ = '\\';
1113     if ((*name!='/') && (*name!='\\'))
1114     {
1115         /* Relative path or empty path */
1116         lstrcpynA( p, DRIVE_GetDosCwd(drive), sizeof(buffer) - 4 );
1117         if ( *p )
1118         {
1119             p += strlen(p);
1120             *p++ = '\\';
1121         }
1122     }
1123
1124     while (*name)
1125     {
1126         while ((*name == '\\') || (*name == '/'))
1127             name++;
1128         if (*name == '.')
1129         {
1130             if (IS_END_OF_NAME(name[1]))
1131             {
1132                 name++;
1133                 continue;
1134             }
1135             else if ((name[1] == '.') && IS_END_OF_NAME(name[2]))
1136             {
1137                 if (p == buffer + 3) {
1138                     /* no previous dir component */
1139                     SetLastError( ERROR_PATH_NOT_FOUND );
1140                     return 0;
1141                 }
1142                 /* skip previously added '\\' */
1143                 p-=2;
1144                 /* skip previous dir component */
1145                 while (*p != '\\')
1146                     p--;
1147                 p++;
1148
1149                 name += 2;
1150                 continue;
1151             }
1152         }
1153         while (!IS_END_OF_NAME(*name) && (p<endbuf) )
1154             *p++ = *name++;
1155         if ((p<endbuf) && ((*name == '\\') || (*name == '/'))) {
1156             *p++='\\';
1157             name++;
1158         }
1159         if ( p==endbuf && *name )
1160         {
1161             SetLastError( ERROR_PATH_NOT_FOUND );
1162             return 0;
1163         }
1164     }
1165     *p = '\0';
1166     /* Only return a trailing \\ if name does end in \\ // or :*/
1167     namelast= name[strlen(name)-1];
1168     if ( (namelast != '\\') && (namelast != '/')&& (namelast != ':') )
1169       {
1170         if(*(p-1) == '\\')
1171           *(p-1) = '\0';
1172       }
1173     if (!(DRIVE_GetFlags(drive) & DRIVE_CASE_PRESERVING))
1174       CharUpperA( buffer );
1175     /* If the lpBuffer buffer is too small, the return value is the
1176     size of the buffer, in characters, required to hold the path
1177     plus the terminating \0 (tested against win95osr, bon 001118)
1178     . */
1179     ret = strlen(buffer);
1180     if (ret >= len )
1181       {
1182         /* don't touch anything when the buffer is not large enough */
1183         SetLastError( ERROR_INSUFFICIENT_BUFFER );
1184         return ret+1;
1185       }
1186     if (result)
1187     {
1188         if (unicode)
1189             lstrcpynAtoW( (LPWSTR)result, buffer, len );
1190         else
1191             lstrcpynA( result, buffer, len );
1192     }
1193
1194     TRACE("returning '%s'\n", buffer );
1195     return ret;
1196 }
1197
1198
1199 /***********************************************************************
1200  *           GetFullPathNameA   (KERNEL32.272)
1201  * NOTES
1202  *   if the path closed with '\', *lastpart is 0
1203  */
1204 DWORD WINAPI GetFullPathNameA( LPCSTR name, DWORD len, LPSTR buffer,
1205                                  LPSTR *lastpart )
1206 {
1207     DWORD ret = DOSFS_DoGetFullPathName( name, len, buffer, FALSE );
1208     if (ret && (ret<=len) && buffer && lastpart)
1209     {
1210         LPSTR p = buffer + strlen(buffer);
1211
1212         if (*p != '\\')
1213         {
1214           while ((p > buffer + 2) && (*p != '\\')) p--;
1215           *lastpart = p + 1;
1216         }
1217         else *lastpart = NULL;
1218     }
1219     return ret;
1220 }
1221
1222
1223 /***********************************************************************
1224  *           GetFullPathNameW   (KERNEL32.273)
1225  */
1226 DWORD WINAPI GetFullPathNameW( LPCWSTR name, DWORD len, LPWSTR buffer,
1227                                  LPWSTR *lastpart )
1228 {
1229     LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
1230     DWORD ret = DOSFS_DoGetFullPathName( nameA, len, (LPSTR)buffer, TRUE );
1231     HeapFree( GetProcessHeap(), 0, nameA );
1232     if (ret && (ret<=len) && buffer && lastpart)
1233     {
1234         LPWSTR p = buffer + lstrlenW(buffer);
1235         if (*p != (WCHAR)'\\')
1236         {
1237             while ((p > buffer + 2) && (*p != (WCHAR)'\\')) p--;
1238             *lastpart = p + 1;
1239         }
1240         else *lastpart = NULL;
1241     }
1242     return ret;
1243 }
1244
1245 /***********************************************************************
1246  *           DOSFS_FindNextEx
1247  */
1248 static int DOSFS_FindNextEx( FIND_FIRST_INFO *info, WIN32_FIND_DATAA *entry )
1249 {
1250     BYTE attr = info->attr | FA_UNUSED | FA_ARCHIVE | FA_RDONLY;
1251     UINT flags = DRIVE_GetFlags( info->drive );
1252     char *p, buffer[MAX_PATHNAME_LEN];
1253     const char *drive_path;
1254     int drive_root;
1255     LPCSTR long_name, short_name;
1256     BY_HANDLE_FILE_INFORMATION fileinfo;
1257     char dos_name[13];
1258
1259     if ((info->attr & ~(FA_UNUSED | FA_ARCHIVE | FA_RDONLY)) == FA_LABEL)
1260     {
1261         if (info->cur_pos) return 0;
1262         entry->dwFileAttributes  = FILE_ATTRIBUTE_LABEL;
1263         DOSFS_UnixTimeToFileTime( (time_t)0, &entry->ftCreationTime, 0 );
1264         DOSFS_UnixTimeToFileTime( (time_t)0, &entry->ftLastAccessTime, 0 );
1265         DOSFS_UnixTimeToFileTime( (time_t)0, &entry->ftLastWriteTime, 0 );
1266         entry->nFileSizeHigh     = 0;
1267         entry->nFileSizeLow      = 0;
1268         entry->dwReserved0       = 0;
1269         entry->dwReserved1       = 0;
1270         DOSFS_ToDosDTAFormat( DRIVE_GetLabel( info->drive ), entry->cFileName );
1271         strcpy( entry->cAlternateFileName, entry->cFileName );
1272         info->cur_pos++;
1273         return 1;
1274     }
1275
1276     drive_path = info->path + strlen(DRIVE_GetRoot( info->drive ));
1277     while ((*drive_path == '/') || (*drive_path == '\\')) drive_path++;
1278     drive_root = !*drive_path;
1279
1280     lstrcpynA( buffer, info->path, sizeof(buffer) - 1 );
1281     strcat( buffer, "/" );
1282     p = buffer + strlen(buffer);
1283
1284     while (DOSFS_ReadDir( info->dir, &long_name, &short_name ))
1285     {
1286         info->cur_pos++;
1287
1288         /* Don't return '.' and '..' in the root of the drive */
1289         if (drive_root && (long_name[0] == '.') &&
1290             (!long_name[1] || ((long_name[1] == '.') && !long_name[2])))
1291             continue;
1292
1293         /* Check the long mask */
1294
1295         if (info->long_mask)
1296         {
1297             if (!DOSFS_MatchLong( info->long_mask, long_name,
1298                                   flags & DRIVE_CASE_SENSITIVE )) continue;
1299         }
1300
1301         /* Check the short mask */
1302
1303         if (info->short_mask)
1304         {
1305             if (!short_name)
1306             {
1307                 DOSFS_Hash( long_name, dos_name, TRUE,
1308                             !(flags & DRIVE_CASE_SENSITIVE) );
1309                 short_name = dos_name;
1310             }
1311             if (!DOSFS_MatchShort( info->short_mask, short_name )) continue;
1312         }
1313
1314         /* Check the file attributes */
1315
1316         lstrcpynA( p, long_name, sizeof(buffer) - (int)(p - buffer) );
1317         if (!FILE_Stat( buffer, &fileinfo ))
1318         {
1319             WARN("can't stat %s\n", buffer);
1320             continue;
1321         }
1322         if (fileinfo.dwFileAttributes & ~attr) continue;
1323
1324         /* We now have a matching entry; fill the result and return */
1325
1326         entry->dwFileAttributes = fileinfo.dwFileAttributes;
1327         entry->ftCreationTime   = fileinfo.ftCreationTime;
1328         entry->ftLastAccessTime = fileinfo.ftLastAccessTime;
1329         entry->ftLastWriteTime  = fileinfo.ftLastWriteTime;
1330         entry->nFileSizeHigh    = fileinfo.nFileSizeHigh;
1331         entry->nFileSizeLow     = fileinfo.nFileSizeLow;
1332
1333         if (short_name)
1334             DOSFS_ToDosDTAFormat( short_name, entry->cAlternateFileName );
1335         else
1336             DOSFS_Hash( long_name, entry->cAlternateFileName, FALSE,
1337                         !(flags & DRIVE_CASE_SENSITIVE) );
1338
1339         lstrcpynA( entry->cFileName, long_name, sizeof(entry->cFileName) );
1340         if (!(flags & DRIVE_CASE_PRESERVING)) CharLowerA( entry->cFileName );
1341         TRACE("returning %s (%s) %02lx %ld\n",
1342               entry->cFileName, entry->cAlternateFileName,
1343               entry->dwFileAttributes, entry->nFileSizeLow );
1344         return 1;
1345     }
1346     return 0;  /* End of directory */
1347 }
1348
1349 /***********************************************************************
1350  *           DOSFS_FindNext
1351  *
1352  * Find the next matching file. Return the number of entries read to find
1353  * the matching one, or 0 if no more entries.
1354  * 'short_mask' is the 8.3 mask (in FCB format), 'long_mask' is the long
1355  * file name mask. Either or both can be NULL.
1356  *
1357  * NOTE: This is supposed to be only called by the int21 emulation
1358  *       routines. Thus, we should own the Win16Mutex anyway.
1359  *       Nevertheless, we explicitly enter it to ensure the static
1360  *       directory cache is protected.
1361  */
1362 int DOSFS_FindNext( const char *path, const char *short_mask,
1363                     const char *long_mask, int drive, BYTE attr,
1364                     int skip, WIN32_FIND_DATAA *entry )
1365 {
1366     static FIND_FIRST_INFO info = { NULL };
1367     LPCSTR short_name, long_name;
1368     int count;
1369
1370     SYSLEVEL_EnterWin16Lock();
1371
1372     /* Check the cached directory */
1373     if (!(info.dir && info.path == path && info.short_mask == short_mask
1374                    && info.long_mask == long_mask && info.drive == drive
1375                    && info.attr == attr && info.cur_pos <= skip))
1376     {
1377         /* Not in the cache, open it anew */
1378         if (info.dir) DOSFS_CloseDir( info.dir );
1379
1380         info.path = (LPSTR)path;
1381         info.long_mask = (LPSTR)long_mask;
1382         info.short_mask = (LPSTR)short_mask;
1383         info.attr = attr;
1384         info.drive = drive;
1385         info.cur_pos = 0;
1386         info.dir = DOSFS_OpenDir( info.path );
1387     }
1388
1389     /* Skip to desired position */
1390     while (info.cur_pos < skip)
1391         if (info.dir && DOSFS_ReadDir( info.dir, &long_name, &short_name ))
1392             info.cur_pos++;
1393         else
1394             break;
1395
1396     if (info.dir && info.cur_pos == skip && DOSFS_FindNextEx( &info, entry ))
1397         count = info.cur_pos - skip;
1398     else
1399         count = 0;
1400
1401     if (!count)
1402     {
1403         if (info.dir) DOSFS_CloseDir( info.dir );
1404         memset( &info, '\0', sizeof(info) );
1405     }
1406
1407     SYSLEVEL_LeaveWin16Lock();
1408
1409     return count;
1410 }
1411
1412
1413
1414 /*************************************************************************
1415  *           FindFirstFile16   (KERNEL.413)
1416  */
1417 HANDLE16 WINAPI FindFirstFile16( LPCSTR path, WIN32_FIND_DATAA *data )
1418 {
1419     DOS_FULL_NAME full_name;
1420     HGLOBAL16 handle;
1421     FIND_FIRST_INFO *info;
1422
1423     data->dwReserved0 = data->dwReserved1 = 0x0;
1424     if (!path) return 0;
1425     if (!DOSFS_GetFullName( path, FALSE, &full_name ))
1426         return INVALID_HANDLE_VALUE16;
1427     if (!(handle = GlobalAlloc16( GMEM_MOVEABLE, sizeof(FIND_FIRST_INFO) )))
1428         return INVALID_HANDLE_VALUE16;
1429     info = (FIND_FIRST_INFO *)GlobalLock16( handle );
1430     info->path = HEAP_strdupA( GetProcessHeap(), 0, full_name.long_name );
1431     info->long_mask = strrchr( info->path, '/' );
1432     *(info->long_mask++) = '\0';
1433     info->short_mask = NULL;
1434     info->attr = 0xff;
1435     if (path[0] && (path[1] == ':')) info->drive = toupper(*path) - 'A';
1436     else info->drive = DRIVE_GetCurrentDrive();
1437     info->cur_pos = 0;
1438
1439     info->dir = DOSFS_OpenDir( info->path );
1440
1441     GlobalUnlock16( handle );
1442     if (!FindNextFile16( handle, data ))
1443     {
1444         FindClose16( handle );
1445         SetLastError( ERROR_NO_MORE_FILES );
1446         return INVALID_HANDLE_VALUE16;
1447     }
1448     return handle;
1449 }
1450
1451
1452 /*************************************************************************
1453  *           FindFirstFileA   (KERNEL32.123)
1454  */
1455 HANDLE WINAPI FindFirstFileA( LPCSTR path, WIN32_FIND_DATAA *data )
1456 {
1457     HANDLE handle = FindFirstFile16( path, data );
1458     if (handle == INVALID_HANDLE_VALUE16) return INVALID_HANDLE_VALUE;
1459     return handle;
1460 }
1461
1462
1463 /*************************************************************************
1464  *           FindFirstFileW   (KERNEL32.124)
1465  */
1466 HANDLE WINAPI FindFirstFileW( LPCWSTR path, WIN32_FIND_DATAW *data )
1467 {
1468     WIN32_FIND_DATAA dataA;
1469     LPSTR pathA = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
1470     HANDLE handle = FindFirstFileA( pathA, &dataA );
1471     HeapFree( GetProcessHeap(), 0, pathA );
1472     if (handle != INVALID_HANDLE_VALUE)
1473     {
1474         data->dwFileAttributes = dataA.dwFileAttributes;
1475         data->ftCreationTime   = dataA.ftCreationTime;
1476         data->ftLastAccessTime = dataA.ftLastAccessTime;
1477         data->ftLastWriteTime  = dataA.ftLastWriteTime;
1478         data->nFileSizeHigh    = dataA.nFileSizeHigh;
1479         data->nFileSizeLow     = dataA.nFileSizeLow;
1480         lstrcpyAtoW( data->cFileName, dataA.cFileName );
1481         lstrcpyAtoW( data->cAlternateFileName, dataA.cAlternateFileName );
1482     }
1483     return handle;
1484 }
1485
1486
1487 /*************************************************************************
1488  *           FindNextFile16   (KERNEL.414)
1489  */
1490 BOOL16 WINAPI FindNextFile16( HANDLE16 handle, WIN32_FIND_DATAA *data )
1491 {
1492     FIND_FIRST_INFO *info;
1493
1494     if (!(info = (FIND_FIRST_INFO *)GlobalLock16( handle )))
1495     {
1496         SetLastError( ERROR_INVALID_HANDLE );
1497         return FALSE;
1498     }
1499     GlobalUnlock16( handle );
1500     if (!info->path || !info->dir)
1501     {
1502         SetLastError( ERROR_NO_MORE_FILES );
1503         return FALSE;
1504     }
1505     if (!DOSFS_FindNextEx( info, data ))
1506     {
1507         DOSFS_CloseDir( info->dir ); info->dir = NULL;
1508         HeapFree( GetProcessHeap(), 0, info->path );
1509         info->path = info->long_mask = NULL;
1510         SetLastError( ERROR_NO_MORE_FILES );
1511         return FALSE;
1512     }
1513     return TRUE;
1514 }
1515
1516
1517 /*************************************************************************
1518  *           FindNextFileA   (KERNEL32.126)
1519  */
1520 BOOL WINAPI FindNextFileA( HANDLE handle, WIN32_FIND_DATAA *data )
1521 {
1522     return FindNextFile16( handle, data );
1523 }
1524
1525
1526 /*************************************************************************
1527  *           FindNextFileW   (KERNEL32.127)
1528  */
1529 BOOL WINAPI FindNextFileW( HANDLE handle, WIN32_FIND_DATAW *data )
1530 {
1531     WIN32_FIND_DATAA dataA;
1532     if (!FindNextFileA( handle, &dataA )) return FALSE;
1533     data->dwFileAttributes = dataA.dwFileAttributes;
1534     data->ftCreationTime   = dataA.ftCreationTime;
1535     data->ftLastAccessTime = dataA.ftLastAccessTime;
1536     data->ftLastWriteTime  = dataA.ftLastWriteTime;
1537     data->nFileSizeHigh    = dataA.nFileSizeHigh;
1538     data->nFileSizeLow     = dataA.nFileSizeLow;
1539     lstrcpyAtoW( data->cFileName, dataA.cFileName );
1540     lstrcpyAtoW( data->cAlternateFileName, dataA.cAlternateFileName );
1541     return TRUE;
1542 }
1543
1544
1545 /*************************************************************************
1546  *           FindClose16   (KERNEL.415)
1547  */
1548 BOOL16 WINAPI FindClose16( HANDLE16 handle )
1549 {
1550     FIND_FIRST_INFO *info;
1551
1552     if ((handle == INVALID_HANDLE_VALUE16) ||
1553         !(info = (FIND_FIRST_INFO *)GlobalLock16( handle )))
1554     {
1555         SetLastError( ERROR_INVALID_HANDLE );
1556         return FALSE;
1557     }
1558     if (info->dir) DOSFS_CloseDir( info->dir );
1559     if (info->path) HeapFree( GetProcessHeap(), 0, info->path );
1560     GlobalUnlock16( handle );
1561     GlobalFree16( handle );
1562     return TRUE;
1563 }
1564
1565
1566 /*************************************************************************
1567  *           FindClose   (KERNEL32.119)
1568  */
1569 BOOL WINAPI FindClose( HANDLE handle )
1570 {
1571     return FindClose16( (HANDLE16)handle );
1572 }
1573
1574
1575 /***********************************************************************
1576  *           DOSFS_UnixTimeToFileTime
1577  *
1578  * Convert a Unix time to FILETIME format.
1579  * The FILETIME structure is a 64-bit value representing the number of
1580  * 100-nanosecond intervals since January 1, 1601, 0:00.
1581  * 'remainder' is the nonnegative number of 100-ns intervals
1582  * corresponding to the time fraction smaller than 1 second that
1583  * couldn't be stored in the time_t value.
1584  */
1585 void DOSFS_UnixTimeToFileTime( time_t unix_time, FILETIME *filetime,
1586                                DWORD remainder )
1587 {
1588     /* NOTES:
1589
1590        CONSTANTS:
1591        The time difference between 1 January 1601, 00:00:00 and
1592        1 January 1970, 00:00:00 is 369 years, plus the leap years
1593        from 1604 to 1968, excluding 1700, 1800, 1900.
1594        This makes (1968 - 1600) / 4 - 3 = 89 leap days, and a total
1595        of 134774 days.
1596
1597        Any day in that period had 24 * 60 * 60 = 86400 seconds.
1598
1599        The time difference is 134774 * 86400 * 10000000, which can be written
1600        116444736000000000
1601        27111902 * 2^32 + 3577643008
1602        413 * 2^48 + 45534 * 2^32 + 54590 * 2^16 + 32768
1603
1604        If you find that these constants are buggy, please change them in all
1605        instances in both conversion functions.
1606
1607        VERSIONS:
1608        There are two versions, one of them uses long long variables and
1609        is presumably faster but not ISO C. The other one uses standard C
1610        data types and operations but relies on the assumption that negative
1611        numbers are stored as 2's complement (-1 is 0xffff....). If this
1612        assumption is violated, dates before 1970 will not convert correctly.
1613        This should however work on any reasonable architecture where WINE
1614        will run.
1615
1616        DETAILS:
1617
1618        Take care not to remove the casts. I have tested these functions
1619        (in both versions) for a lot of numbers. I would be interested in
1620        results on other compilers than GCC.
1621
1622        The operations have been designed to account for the possibility
1623        of 64-bit time_t in future UNICES. Even the versions without
1624        internal long long numbers will work if time_t only is 64 bit.
1625        A 32-bit shift, which was necessary for that operation, turned out
1626        not to work correctly in GCC, besides giving the warning. So I
1627        used a double 16-bit shift instead. Numbers are in the ISO version
1628        represented by three limbs, the most significant with 32 bit, the
1629        other two with 16 bit each.
1630
1631        As the modulo-operator % is not well-defined for negative numbers,
1632        negative divisors have been avoided in DOSFS_FileTimeToUnixTime.
1633
1634        There might be quicker ways to do this in C. Certainly so in
1635        assembler.
1636
1637        Claus Fischer, fischer@iue.tuwien.ac.at
1638        */
1639
1640 #if SIZEOF_LONG_LONG >= 8
1641 #  define USE_LONG_LONG 1
1642 #else
1643 #  define USE_LONG_LONG 0
1644 #endif
1645
1646 #if USE_LONG_LONG               /* gcc supports long long type */
1647
1648     long long int t = unix_time;
1649     t *= 10000000;
1650     t += 116444736000000000LL;
1651     t += remainder;
1652     filetime->dwLowDateTime  = (UINT)t;
1653     filetime->dwHighDateTime = (UINT)(t >> 32);
1654
1655 #else  /* ISO version */
1656
1657     UINT a0;                    /* 16 bit, low    bits */
1658     UINT a1;                    /* 16 bit, medium bits */
1659     UINT a2;                    /* 32 bit, high   bits */
1660
1661     /* Copy the unix time to a2/a1/a0 */
1662     a0 =  unix_time & 0xffff;
1663     a1 = (unix_time >> 16) & 0xffff;
1664     /* This is obsolete if unix_time is only 32 bits, but it does not hurt.
1665        Do not replace this by >> 32, it gives a compiler warning and it does
1666        not work. */
1667     a2 = (unix_time >= 0 ? (unix_time >> 16) >> 16 :
1668           ~((~unix_time >> 16) >> 16));
1669
1670     /* Multiply a by 10000000 (a = a2/a1/a0)
1671        Split the factor into 10000 * 1000 which are both less than 0xffff. */
1672     a0 *= 10000;
1673     a1 = a1 * 10000 + (a0 >> 16);
1674     a2 = a2 * 10000 + (a1 >> 16);
1675     a0 &= 0xffff;
1676     a1 &= 0xffff;
1677
1678     a0 *= 1000;
1679     a1 = a1 * 1000 + (a0 >> 16);
1680     a2 = a2 * 1000 + (a1 >> 16);
1681     a0 &= 0xffff;
1682     a1 &= 0xffff;
1683
1684     /* Add the time difference and the remainder */
1685     a0 += 32768 + (remainder & 0xffff);
1686     a1 += 54590 + (remainder >> 16   ) + (a0 >> 16);
1687     a2 += 27111902                     + (a1 >> 16);
1688     a0 &= 0xffff;
1689     a1 &= 0xffff;
1690
1691     /* Set filetime */
1692     filetime->dwLowDateTime  = (a1 << 16) + a0;
1693     filetime->dwHighDateTime = a2;
1694 #endif
1695 }
1696
1697
1698 /***********************************************************************
1699  *           DOSFS_FileTimeToUnixTime
1700  *
1701  * Convert a FILETIME format to Unix time.
1702  * If not NULL, 'remainder' contains the fractional part of the filetime,
1703  * in the range of [0..9999999] (even if time_t is negative).
1704  */
1705 time_t DOSFS_FileTimeToUnixTime( const FILETIME *filetime, DWORD *remainder )
1706 {
1707     /* Read the comment in the function DOSFS_UnixTimeToFileTime. */
1708 #if USE_LONG_LONG
1709
1710     long long int t = filetime->dwHighDateTime;
1711     t <<= 32;
1712     t += (UINT)filetime->dwLowDateTime;
1713     t -= 116444736000000000LL;
1714     if (t < 0)
1715     {
1716         if (remainder) *remainder = 9999999 - (-t - 1) % 10000000;
1717         return -1 - ((-t - 1) / 10000000);
1718     }
1719     else
1720     {
1721         if (remainder) *remainder = t % 10000000;
1722         return t / 10000000;
1723     }
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     UINT r;                     /* remainder of division */
1731     unsigned int carry;         /* carry bit for subtraction */
1732     int negative;               /* whether a represents a negative value */
1733
1734     /* Copy the time values to a2/a1/a0 */
1735     a2 =  (UINT)filetime->dwHighDateTime;
1736     a1 = ((UINT)filetime->dwLowDateTime ) >> 16;
1737     a0 = ((UINT)filetime->dwLowDateTime ) & 0xffff;
1738
1739     /* Subtract the time difference */
1740     if (a0 >= 32768           ) a0 -=             32768        , carry = 0;
1741     else                        a0 += (1 << 16) - 32768        , carry = 1;
1742
1743     if (a1 >= 54590    + carry) a1 -=             54590 + carry, carry = 0;
1744     else                        a1 += (1 << 16) - 54590 - carry, carry = 1;
1745
1746     a2 -= 27111902 + carry;
1747
1748     /* If a is negative, replace a by (-1-a) */
1749     negative = (a2 >= ((UINT)1) << 31);
1750     if (negative)
1751     {
1752         /* Set a to -a - 1 (a is a2/a1/a0) */
1753         a0 = 0xffff - a0;
1754         a1 = 0xffff - a1;
1755         a2 = ~a2;
1756     }
1757
1758     /* Divide a by 10000000 (a = a2/a1/a0), put the rest into r.
1759        Split the divisor into 10000 * 1000 which are both less than 0xffff. */
1760     a1 += (a2 % 10000) << 16;
1761     a2 /=       10000;
1762     a0 += (a1 % 10000) << 16;
1763     a1 /=       10000;
1764     r   =  a0 % 10000;
1765     a0 /=       10000;
1766
1767     a1 += (a2 % 1000) << 16;
1768     a2 /=       1000;
1769     a0 += (a1 % 1000) << 16;
1770     a1 /=       1000;
1771     r  += (a0 % 1000) * 10000;
1772     a0 /=       1000;
1773
1774     /* If a was negative, replace a by (-1-a) and r by (9999999 - r) */
1775     if (negative)
1776     {
1777         /* Set a to -a - 1 (a is a2/a1/a0) */
1778         a0 = 0xffff - a0;
1779         a1 = 0xffff - a1;
1780         a2 = ~a2;
1781
1782         r  = 9999999 - r;
1783     }
1784
1785     if (remainder) *remainder = r;
1786
1787     /* Do not replace this by << 32, it gives a compiler warning and it does
1788        not work. */
1789     return ((((time_t)a2) << 16) << 16) + (a1 << 16) + a0;
1790 #endif
1791 }
1792
1793
1794 /***********************************************************************
1795  *           DosDateTimeToFileTime   (KERNEL32.76)
1796  */
1797 BOOL WINAPI DosDateTimeToFileTime( WORD fatdate, WORD fattime, LPFILETIME ft)
1798 {
1799     struct tm newtm;
1800
1801     newtm.tm_sec  = (fattime & 0x1f) * 2;
1802     newtm.tm_min  = (fattime >> 5) & 0x3f;
1803     newtm.tm_hour = (fattime >> 11);
1804     newtm.tm_mday = (fatdate & 0x1f);
1805     newtm.tm_mon  = ((fatdate >> 5) & 0x0f) - 1;
1806     newtm.tm_year = (fatdate >> 9) + 80;
1807     DOSFS_UnixTimeToFileTime( mktime( &newtm ), ft, 0 );
1808     return TRUE;
1809 }
1810
1811
1812 /***********************************************************************
1813  *           FileTimeToDosDateTime   (KERNEL32.111)
1814  */
1815 BOOL WINAPI FileTimeToDosDateTime( const FILETIME *ft, LPWORD fatdate,
1816                                      LPWORD fattime )
1817 {
1818     time_t unixtime = DOSFS_FileTimeToUnixTime( ft, NULL );
1819     struct tm *tm = localtime( &unixtime );
1820     if (fattime)
1821         *fattime = (tm->tm_hour << 11) + (tm->tm_min << 5) + (tm->tm_sec / 2);
1822     if (fatdate)
1823         *fatdate = ((tm->tm_year - 80) << 9) + ((tm->tm_mon + 1) << 5)
1824                    + tm->tm_mday;
1825     return TRUE;
1826 }
1827
1828
1829 /***********************************************************************
1830  *           LocalFileTimeToFileTime   (KERNEL32.373)
1831  */
1832 BOOL WINAPI LocalFileTimeToFileTime( const FILETIME *localft,
1833                                        LPFILETIME utcft )
1834 {
1835     struct tm *xtm;
1836     DWORD remainder;
1837
1838     /* convert from local to UTC. Perhaps not correct. FIXME */
1839     time_t unixtime = DOSFS_FileTimeToUnixTime( localft, &remainder );
1840     xtm = gmtime( &unixtime );
1841     DOSFS_UnixTimeToFileTime( mktime(xtm), utcft, remainder );
1842     return TRUE;
1843 }
1844
1845
1846 /***********************************************************************
1847  *           FileTimeToLocalFileTime   (KERNEL32.112)
1848  */
1849 BOOL WINAPI FileTimeToLocalFileTime( const FILETIME *utcft,
1850                                        LPFILETIME localft )
1851 {
1852     DWORD remainder;
1853     /* convert from UTC to local. Perhaps not correct. FIXME */
1854     time_t unixtime = DOSFS_FileTimeToUnixTime( utcft, &remainder );
1855 #ifdef HAVE_TIMEGM
1856     struct tm *xtm = localtime( &unixtime );
1857     time_t localtime;
1858
1859     localtime = timegm(xtm);
1860     DOSFS_UnixTimeToFileTime( localtime, localft, remainder );
1861
1862 #else
1863     struct tm *xtm,*gtm;
1864     time_t time1,time2;
1865
1866     xtm = localtime( &unixtime );
1867     gtm = gmtime( &unixtime );
1868     time1 = mktime(xtm);
1869     time2 = mktime(gtm);
1870     DOSFS_UnixTimeToFileTime( 2*time1-time2, localft, remainder );
1871 #endif
1872     return TRUE;
1873 }
1874
1875
1876 /***********************************************************************
1877  *           FileTimeToSystemTime   (KERNEL32.113)
1878  */
1879 BOOL WINAPI FileTimeToSystemTime( const FILETIME *ft, LPSYSTEMTIME syst )
1880 {
1881     struct tm *xtm;
1882     DWORD remainder;
1883     time_t xtime = DOSFS_FileTimeToUnixTime( ft, &remainder );
1884     xtm = gmtime(&xtime);
1885     syst->wYear         = xtm->tm_year+1900;
1886     syst->wMonth        = xtm->tm_mon + 1;
1887     syst->wDayOfWeek    = xtm->tm_wday;
1888     syst->wDay          = xtm->tm_mday;
1889     syst->wHour         = xtm->tm_hour;
1890     syst->wMinute       = xtm->tm_min;
1891     syst->wSecond       = xtm->tm_sec;
1892     syst->wMilliseconds = remainder / 10000;
1893     return TRUE;
1894 }
1895
1896 /***********************************************************************
1897  *           QueryDosDeviceA   (KERNEL32.413)
1898  *
1899  * returns array of strings terminated by \0, terminated by \0
1900  */
1901 DWORD WINAPI QueryDosDeviceA(LPCSTR devname,LPSTR target,DWORD bufsize)
1902 {
1903     LPSTR s;
1904     char  buffer[200];
1905
1906     TRACE("(%s,...)\n", devname ? devname : "<null>");
1907     if (!devname) {
1908         /* return known MSDOS devices */
1909         strcpy(buffer,"CON COM1 COM2 LPT1 NUL ");
1910         while ((s=strchr(buffer,' ')))
1911                 *s='\0';
1912
1913         lstrcpynA(target,buffer,bufsize);
1914         return strlen(buffer);
1915     }
1916     strcpy(buffer,"\\DEV\\");
1917     strcat(buffer,devname);
1918     if ((s=strchr(buffer,':'))) *s='\0';
1919     lstrcpynA(target,buffer,bufsize);
1920     return strlen(buffer);
1921 }
1922
1923
1924 /***********************************************************************
1925  *           QueryDosDeviceW   (KERNEL32.414)
1926  *
1927  * returns array of strings terminated by \0, terminated by \0
1928  */
1929 DWORD WINAPI QueryDosDeviceW(LPCWSTR devname,LPWSTR target,DWORD bufsize)
1930 {
1931     LPSTR devnameA = devname?HEAP_strdupWtoA(GetProcessHeap(),0,devname):NULL;
1932     LPSTR targetA = (LPSTR)HEAP_xalloc(GetProcessHeap(),0,bufsize);
1933     DWORD ret = QueryDosDeviceA(devnameA,targetA,bufsize);
1934
1935     lstrcpynAtoW(target,targetA,bufsize);
1936     if (devnameA) HeapFree(GetProcessHeap(),0,devnameA);
1937     if (targetA) HeapFree(GetProcessHeap(),0,targetA);
1938     return ret;
1939 }
1940
1941
1942 /***********************************************************************
1943  *           SystemTimeToFileTime   (KERNEL32.526)
1944  */
1945 BOOL WINAPI SystemTimeToFileTime( const SYSTEMTIME *syst, LPFILETIME ft )
1946 {
1947 #ifdef HAVE_TIMEGM
1948     struct tm xtm;
1949     time_t utctime;
1950 #else
1951     struct tm xtm,*local_tm,*utc_tm;
1952     time_t localtim,utctime;
1953 #endif
1954
1955     xtm.tm_year = syst->wYear-1900;
1956     xtm.tm_mon  = syst->wMonth - 1;
1957     xtm.tm_wday = syst->wDayOfWeek;
1958     xtm.tm_mday = syst->wDay;
1959     xtm.tm_hour = syst->wHour;
1960     xtm.tm_min  = syst->wMinute;
1961     xtm.tm_sec  = syst->wSecond; /* this is UTC */
1962     xtm.tm_isdst = -1;
1963 #ifdef HAVE_TIMEGM
1964     utctime = timegm(&xtm);
1965     DOSFS_UnixTimeToFileTime( utctime, ft,
1966                               syst->wMilliseconds * 10000 );
1967 #else
1968     localtim = mktime(&xtm);    /* now we've got local time */
1969     local_tm = localtime(&localtim);
1970     utc_tm = gmtime(&localtim);
1971     utctime = mktime(utc_tm);
1972     DOSFS_UnixTimeToFileTime( 2*localtim -utctime, ft,
1973                               syst->wMilliseconds * 10000 );
1974 #endif
1975     return TRUE;
1976 }
1977
1978 /***********************************************************************
1979  *           DefineDosDeviceA       (KERNEL32.182)
1980  */
1981 BOOL WINAPI DefineDosDeviceA(DWORD flags,LPCSTR devname,LPCSTR targetpath) {
1982         FIXME("(0x%08lx,%s,%s),stub!\n",flags,devname,targetpath);
1983         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1984         return FALSE;
1985 }