files/dos_fs.c

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