?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use sigsetjmp instead of setjmp in Wine internal exception handlers to
[wine/wine64.git] / files / dos_fs.c
blob3712c00b6616a7fee0090ee5060515032371ceb4
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(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(CP_UNIXCP, 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(CP_UNIXCP, 0, de[1].d_name, -1, long_name, MAX_PATH);
512 else
513 MultiByteToWideChar(CP_UNIXCP, 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( 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(CP_UNIXCP, 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( 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( &dir, unix_path);
586
587 if(!r)
588 r = DOSFS_OpenDir_Normal( &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( 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(CP_UNIXCP, 0, long_name, -1, long_buf, long_len, NULL, NULL);
806 if (short_buf)
807 {
808 if (short_name)
809 DOSFS_ToDosDTAFormat( short_name, short_buf );
810 else
811 DOSFS_Hash( long_name, short_buf, FALSE, ignore_case );
812 }
813 TRACE("(%s,%s) -> %s (%s)\n", path->long_name, debugstr_w(name),
814 debugstr_w(long_name), short_buf ? debugstr_w(short_buf) : "***");
815 }
816 else
817 WARN("%s not found in '%s'\n", debugstr_w(name), path->long_name);
818 DOSFS_CloseDir( dir );
819 return ret;
820 }
821
822
823 /***********************************************************************
824 * DOSFS_GetDevice
825 *
826 * Check if a DOS file name represents a DOS device and return the device.
827 */
828 const DOS_DEVICE *DOSFS_GetDevice( LPCWSTR name )
829 {
830 unsigned int i;
831 const WCHAR *p;
832
833 if (!name) return NULL; /* if wine_server_handle_to_fd was used */
834 if (name[0] && (name[1] == ':')) name += 2;
835 if ((p = strrchrW( name, '/' ))) name = p + 1;
836 if ((p = strrchrW( name, '\\' ))) name = p + 1;
837 for (i = 0; i < sizeof(DOSFS_Devices)/sizeof(DOSFS_Devices[0]); i++)
838 {
839 const WCHAR *dev = DOSFS_Devices[i].name;
840 if (!strncmpiW( dev, name, strlenW(dev) ))
841 {
842 p = name + strlenW( dev );
843 if (!*p || (*p == '.') || (*p == ':')) return &DOSFS_Devices[i];
844 }
845 }
846 return NULL;
847 }
848
849
850 /***********************************************************************
851 * DOSFS_GetDeviceByHandle
852 */
853 const DOS_DEVICE *DOSFS_GetDeviceByHandle( HANDLE hFile )
854 {
855 const DOS_DEVICE *ret = NULL;
856 SERVER_START_REQ( get_device_id )
857 {
858 req->handle = hFile;
859 if (!wine_server_call( req ))
860 {
861 if ((reply->id >= 0) &&
862 (reply->id < sizeof(DOSFS_Devices)/sizeof(DOSFS_Devices[0])))
863 ret = &DOSFS_Devices[reply->id];
864 }
865 }
866 SERVER_END_REQ;
867 return ret;
868 }
869
870
871 /**************************************************************************
872 * DOSFS_CreateCommPort
873 */
874 static HANDLE DOSFS_CreateCommPort(LPCWSTR name, DWORD access, DWORD attributes, LPSECURITY_ATTRIBUTES sa)
875 {
876 HANDLE ret;
877 HKEY hkey;
878 DWORD dummy;
879 OBJECT_ATTRIBUTES attr;
880 UNICODE_STRING nameW;
881 WCHAR *devnameW;
882 char tmp[128];
883 char devname[40];
884
885 static const WCHAR serialportsW[] = {'M','a','c','h','i','n','e','\\',
886 'S','o','f','t','w','a','r','e','\\',
887 'W','i','n','e','\\','W','i','n','e','\\',
888 'C','o','n','f','i','g','\\',
889 'S','e','r','i','a','l','P','o','r','t','s',0};
890
891 TRACE_(file)("%s %lx %lx\n", debugstr_w(name), access, attributes);
892
893 attr.Length = sizeof(attr);
894 attr.RootDirectory = 0;
895 attr.ObjectName = &nameW;
896 attr.Attributes = 0;
897 attr.SecurityDescriptor = NULL;
898 attr.SecurityQualityOfService = NULL;
899 RtlInitUnicodeString( &nameW, serialportsW );
900
901 if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr )) return 0;
902
903 RtlInitUnicodeString( &nameW, name );
904 if (!NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, tmp, sizeof(tmp), &dummy ))
905 devnameW = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)tmp)->Data;
906 else
907 devnameW = NULL;
908
909 NtClose( hkey );
910
911 if (!devnameW) return 0;
912 WideCharToMultiByte(CP_ACP, 0, devnameW, -1, devname, sizeof(devname), NULL, NULL);
913
914 TRACE("opening %s as %s\n", devname, debugstr_w(name));
915
916 SERVER_START_REQ( create_serial )
917 {
918 req->access = access;
919 req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
920 req->attributes = attributes;
921 req->sharing = FILE_SHARE_READ|FILE_SHARE_WRITE;
922 wine_server_add_data( req, devname, strlen(devname) );
923 SetLastError(0);
924 wine_server_call_err( req );
925 ret = reply->handle;
926 }
927 SERVER_END_REQ;
928
929 if(!ret)
930 ERR("Couldn't open device '%s' ! (check permissions)\n",devname);
931 else
932 TRACE("return %p\n", ret );
933 return ret;
934 }
935
936 /***********************************************************************
937 * DOSFS_OpenDevice
938 *
939 * Open a DOS device. This might not map 1:1 into the UNIX device concept.
940 * Returns 0 on failure.
941 */
942 HANDLE DOSFS_OpenDevice( LPCWSTR name, DWORD access, DWORD attributes, LPSECURITY_ATTRIBUTES sa )
943 {
944 unsigned int i;
945 const WCHAR *p;
946 HANDLE handle;
947
948 if (name[0] && (name[1] == ':')) name += 2;
949 if ((p = strrchrW( name, '/' ))) name = p + 1;
950 if ((p = strrchrW( name, '\\' ))) name = p + 1;
951 for (i = 0; i < sizeof(DOSFS_Devices)/sizeof(DOSFS_Devices[0]); i++)
952 {
953 const WCHAR *dev = DOSFS_Devices[i].name;
954 if (!strncmpiW( dev, name, strlenW(dev) ))
955 {
956 p = name + strlenW( dev );
957 if (!*p || (*p == '.') || (*p == ':')) {
958 static const WCHAR nulW[] = {'N','U','L',0};
959 static const WCHAR conW[] = {'C','O','N',0};
960 static const WCHAR scsimgrW[] = {'S','C','S','I','M','G','R','$',0};
961 static const WCHAR hpscanW[] = {'H','P','S','C','A','N',0};
962 static const WCHAR emmxxxx0W[] = {'E','M','M','X','X','X','X','0',0};
963 /* got it */
964 if (!strcmpiW(DOSFS_Devices[i].name, nulW))
965 return FILE_CreateFile( "/dev/null", access,
966 FILE_SHARE_READ|FILE_SHARE_WRITE, sa,
967 OPEN_EXISTING, 0, 0, TRUE, DRIVE_UNKNOWN );
968 if (!strcmpiW(DOSFS_Devices[i].name, conW)) {
969 HANDLE to_dup;
970 switch (access & (GENERIC_READ|GENERIC_WRITE)) {
971 case GENERIC_READ:
972 to_dup = GetStdHandle( STD_INPUT_HANDLE );
973 break;
974 case GENERIC_WRITE:
975 to_dup = GetStdHandle( STD_OUTPUT_HANDLE );
976 break;
977 default:
978 FIXME("can't open CON read/write\n");
979 return 0;
980 }
981 if (!DuplicateHandle( GetCurrentProcess(), to_dup, GetCurrentProcess(),
982 &handle, 0,
983 sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle,
984 DUPLICATE_SAME_ACCESS ))
985 handle = 0;
986 return handle;
987 }
988 if (!strcmpiW(DOSFS_Devices[i].name, scsimgrW) ||
989 !strcmpiW(DOSFS_Devices[i].name, hpscanW) ||
990 !strcmpiW(DOSFS_Devices[i].name, emmxxxx0W))
991 {
992 return FILE_CreateDevice( i, access, sa );
993 }
994
995 if( (handle=DOSFS_CreateCommPort(DOSFS_Devices[i].name,access,attributes,sa)) )
996 return handle;
997 FIXME("device open %s not supported (yet)\n", debugstr_w(DOSFS_Devices[i].name));
998 return 0;
999 }
1000 }
1001 }
1002 return 0;
1003 }
1004
1005
1006 /***********************************************************************
1007 * DOSFS_GetPathDrive
1008 *
1009 * Get the drive specified by a given path name (DOS or Unix format).
1010 */
1011 static int DOSFS_GetPathDrive( LPCWSTR *name )
1012 {
1013 int drive;
1014 LPCWSTR p = *name;
1015
1016 if (*p && (p[1] == ':'))
1017 {
1018 drive = toupperW(*p) - 'A';
1019 *name += 2;
1020 }
1021 else if (*p == '/') /* Absolute Unix path? */
1022 {
1023 if ((drive = DRIVE_FindDriveRootW( name )) == -1)
1024 {
1025 MESSAGE("Warning: %s not accessible from a configured DOS drive\n", debugstr_w(*name) );
1026 /* Assume it really was a DOS name */
1027 drive = DRIVE_GetCurrentDrive();
1028 }
1029 }
1030 else drive = DRIVE_GetCurrentDrive();
1031
1032 if (!DRIVE_IsValid(drive))
1033 {
1034 SetLastError( ERROR_INVALID_DRIVE );
1035 return -1;
1036 }
1037 return drive;
1038 }
1039
1040
1041 /***********************************************************************
1042 * DOSFS_GetFullName
1043 *
1044 * Convert a file name (DOS or mixed DOS/Unix format) to a valid
1045 * Unix name / short DOS name pair.
1046 * Return FALSE if one of the path components does not exist. The last path
1047 * component is only checked if 'check_last' is non-zero.
1048 * The buffers pointed to by 'long_buf' and 'short_buf' must be
1049 * at least MAX_PATHNAME_LEN long.
1050 */
1051 BOOL DOSFS_GetFullName( LPCWSTR name, BOOL check_last, DOS_FULL_NAME *full )
1052 {
1053 BOOL found;
1054 UINT flags;
1055 char *p_l, *root;
1056 LPWSTR p_s;
1057 static const WCHAR driveA_rootW[] = {'A',':','\\',0};
1058 static const WCHAR dos_rootW[] = {'\\',0};
1059
1060 TRACE("%s (last=%d)\n", debugstr_w(name), check_last );
1061
1062 if ((!*name) || (*name=='\n'))
1063 { /* error code for Win98 */
1064 SetLastError(ERROR_BAD_PATHNAME);
1065 return FALSE;
1066 }
1067
1068 if ((full->drive = DOSFS_GetPathDrive( &name )) == -1) return FALSE;
1069 flags = DRIVE_GetFlags( full->drive );
1070
1071 lstrcpynA( full->long_name, DRIVE_GetRoot( full->drive ),
1072 sizeof(full->long_name) );
1073 if (full->long_name[1]) root = full->long_name + strlen(full->long_name);
1074 else root = full->long_name; /* root directory */
1075
1076 strcpyW( full->short_name, driveA_rootW );
1077 full->short_name[0] += full->drive;
1078
1079 if ((*name == '\\') || (*name == '/')) /* Absolute path */
1080 {
1081 while ((*name == '\\') || (*name == '/')) name++;
1082 }
1083 else /* Relative path */
1084 {
1085 lstrcpynA( root + 1, DRIVE_GetUnixCwd( full->drive ),
1086 sizeof(full->long_name) - (root - full->long_name) - 1 );
1087 if (root[1]) *root = '/';
1088 lstrcpynW( full->short_name + 3, DRIVE_GetDosCwd( full->drive ),
1089 sizeof(full->short_name)/sizeof(full->short_name[0]) - 3 );
1090 }
1091
1092 p_l = full->long_name[1] ? full->long_name + strlen(full->long_name)
1093 : full->long_name;
1094 p_s = full->short_name[3] ? full->short_name + strlenW(full->short_name)
1095 : full->short_name + 2;
1096 found = TRUE;
1097
1098 while (*name && found)
1099 {
1100 /* Check for '.' and '..' */
1101
1102 if (*name == '.')
1103 {
1104 if (IS_END_OF_NAME(name[1]))
1105 {
1106 name++;
1107 while ((*name == '\\') || (*name == '/')) name++;
1108 continue;
1109 }
1110 else if ((name[1] == '.') && IS_END_OF_NAME(name[2]))
1111 {
1112 name += 2;
1113 while ((*name == '\\') || (*name == '/')) name++;
1114 while ((p_l > root) && (*p_l != '/')) p_l--;
1115 while ((p_s > full->short_name + 2) && (*p_s != '\\')) p_s--;
1116 *p_l = *p_s = '\0'; /* Remove trailing separator */
1117 continue;
1118 }
1119 }
1120
1121 /* Make sure buffers are large enough */
1122
1123 if ((p_s >= full->short_name + sizeof(full->short_name)/sizeof(full->short_name[0]) - 14) ||
1124 (p_l >= full->long_name + sizeof(full->long_name) - 1))
1125 {
1126 SetLastError( ERROR_PATH_NOT_FOUND );
1127 return FALSE;
1128 }
1129
1130 /* Get the long and short name matching the file name */
1131
1132 if ((found = DOSFS_FindUnixName( full, name, p_l + 1,
1133 sizeof(full->long_name) - (p_l - full->long_name) - 1,
1134 p_s + 1, !(flags & DRIVE_CASE_SENSITIVE) )))
1135 {
1136 *p_l++ = '/';
1137 p_l += strlen(p_l);
1138 *p_s++ = '\\';
1139 p_s += strlenW(p_s);
1140 while (!IS_END_OF_NAME(*name)) name++;
1141 }
1142 else if (!check_last)
1143 {
1144 *p_l++ = '/';
1145 *p_s++ = '\\';
1146 while (!IS_END_OF_NAME(*name) &&
1147 (p_s < full->short_name + sizeof(full->short_name)/sizeof(full->short_name[0]) - 1) &&
1148 (p_l < full->long_name + sizeof(full->long_name) - 1))
1149 {
1150 WCHAR wch;
1151 *p_s++ = tolowerW(*name);
1152 /* If the drive is case-sensitive we want to create new */
1153 /* files in lower-case otherwise we can't reopen them */
1154 /* under the same short name. */
1155 if (flags & DRIVE_CASE_SENSITIVE) wch = tolowerW(*name);
1156 else wch = *name;
1157 p_l += WideCharToMultiByte(CP_UNIXCP, 0, &wch, 1, p_l, 2, NULL, NULL);
1158 name++;
1159 }
1160 /* Ignore trailing dots and spaces */
1161 while(p_l[-1] == '.' || p_l[-1] == ' ') {
1162 --p_l;
1163 --p_s;
1164 }
1165 *p_l = '\0';
1166 *p_s = '\0';
1167 }
1168 while ((*name == '\\') || (*name == '/')) name++;
1169 }
1170
1171 if (!found)
1172 {
1173 if (check_last)
1174 {
1175 SetLastError( ERROR_FILE_NOT_FOUND );
1176 return FALSE;
1177 }
1178 if (*name) /* Not last */
1179 {
1180 SetLastError( ERROR_PATH_NOT_FOUND );
1181 return FALSE;
1182 }
1183 }
1184 if (!full->long_name[0]) strcpy( full->long_name, "/" );
1185 if (!full->short_name[2]) strcpyW( full->short_name + 2, dos_rootW );
1186 TRACE("returning %s = %s\n", full->long_name, debugstr_w(full->short_name) );
1187 return TRUE;
1188 }
1189
1190
1191 /***********************************************************************
1192 * GetShortPathNameW (KERNEL32.@)
1193 *
1194 * NOTES
1195 * observed:
1196 * longpath=NULL: LastError=ERROR_INVALID_PARAMETER, ret=0
1197 * longpath="" or invalid: LastError=ERROR_BAD_PATHNAME, ret=0
1198 *
1199 * more observations ( with NT 3.51 (WinDD) ):
1200 * longpath <= 8.3 -> just copy longpath to shortpath
1201 * longpath > 8.3 ->
1202 * a) file does not exist -> return 0, LastError = ERROR_FILE_NOT_FOUND
1203 * b) file does exist -> set the short filename.
1204 * - trailing slashes are reproduced in the short name, even if the
1205 * file is not a directory
1206 * - the absolute/relative path of the short name is reproduced like found
1207 * in the long name
1208 * - longpath and shortpath may have the same address
1209 * Peter Ganten, 1999
1210 */
1211 DWORD WINAPI GetShortPathNameW( LPCWSTR longpath, LPWSTR shortpath, DWORD shortlen )
1212 {
1213 DOS_FULL_NAME full_name;
1214 WCHAR tmpshortpath[MAX_PATHNAME_LEN];
1215 const WCHAR *p;
1216 DWORD sp = 0, lp = 0;
1217 int drive;
1218 DWORD tmplen;
1219 UINT flags;
1220 BOOL unixabsolute = *longpath == '/';
1221
1222 TRACE("%s\n", debugstr_w(longpath));
1223
1224 if (!longpath) {
1225 SetLastError(ERROR_INVALID_PARAMETER);
1226 return 0;
1227 }
1228 if (!longpath[0]) {
1229 SetLastError(ERROR_BAD_PATHNAME);
1230 return 0;
1231 }
1232
1233 /* check for drive letter */
1234 if (!unixabsolute && longpath[1] == ':' ) {
1235 tmpshortpath[0] = longpath[0];
1236 tmpshortpath[1] = ':';
1237 sp = 2;
1238 }
1239
1240 if ( ( drive = DOSFS_GetPathDrive ( &longpath )) == -1 ) return 0;
1241 flags = DRIVE_GetFlags ( drive );
1242
1243 if (unixabsolute && drive != DRIVE_GetCurrentDrive()) {
1244 tmpshortpath[0] = drive + 'A';
1245 tmpshortpath[1] = ':';
1246 sp = 2;
1247 }
1248
1249 while ( longpath[lp] ) {
1250
1251 /* check for path delimiters and reproduce them */
1252 if ( longpath[lp] == '\\' || longpath[lp] == '/' ) {
1253 if (!sp || tmpshortpath[sp-1]!= '\\')
1254 {
1255 /* strip double "\\" */
1256 tmpshortpath[sp] = '\\';
1257 sp++;
1258 }
1259 tmpshortpath[sp]=0;/*terminate string*/
1260 lp++;
1261 continue;
1262 }
1263
1264 tmplen = 0;
1265 for(p = longpath + lp; *p && *p != '/' && *p != '\\'; p++)
1266 tmplen++;
1267 lstrcpynW(tmpshortpath + sp, longpath + lp, tmplen + 1);
1268
1269 /* Check, if the current element is a valid dos name */
1270 if ( DOSFS_ValidDOSName ( longpath + lp, !(flags & DRIVE_CASE_SENSITIVE) ) ) {
1271 sp += tmplen;
1272 lp += tmplen;
1273 continue;
1274 }
1275
1276 /* Check if the file exists and use the existing file name */
1277 if ( DOSFS_GetFullName ( tmpshortpath, TRUE, &full_name ) ) {
1278 strcpyW(tmpshortpath + sp, strrchrW(full_name.short_name, '\\') + 1);
1279 sp += strlenW(tmpshortpath + sp);
1280 lp += tmplen;
1281 continue;
1282 }
1283
1284 TRACE("not found!\n" );
1285 SetLastError ( ERROR_FILE_NOT_FOUND );
1286 return 0;
1287 }
1288 tmpshortpath[sp] = 0;
1289
1290 tmplen = strlenW(tmpshortpath) + 1;
1291 if (tmplen <= shortlen)
1292 {
1293 strcpyW(shortpath, tmpshortpath);
1294 TRACE("returning %s\n", debugstr_w(shortpath));
1295 tmplen--; /* length without 0 */
1296 }
1297
1298 return tmplen;
1299 }
1300
1301
1302 /***********************************************************************
1303 * GetShortPathNameA (KERNEL32.@)
1304 */
1305 DWORD WINAPI GetShortPathNameA( LPCSTR longpath, LPSTR shortpath, DWORD shortlen )
1306 {
1307 UNICODE_STRING longpathW;
1308 WCHAR shortpathW[MAX_PATH];
1309 DWORD ret, retW;
1310
1311 if (!longpath)
1312 {
1313 SetLastError(ERROR_INVALID_PARAMETER);
1314 return 0;
1315 }
1316
1317 TRACE("%s\n", debugstr_a(longpath));
1318
1319 if (!RtlCreateUnicodeStringFromAsciiz(&longpathW, longpath))
1320 {
1321 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1322 return 0;
1323 }
1324
1325 retW = GetShortPathNameW(longpathW.Buffer, shortpathW, MAX_PATH);
1326
1327 if (!retW)
1328 ret = 0;
1329 else if (retW > MAX_PATH)
1330 {
1331 SetLastError(ERROR_FILENAME_EXCED_RANGE);
1332 ret = 0;
1333 }
1334 else
1335 {
1336 ret = WideCharToMultiByte(CP_ACP, 0, shortpathW, -1, NULL, 0, NULL, NULL);
1337 if (ret <= shortlen)
1338 {
1339 WideCharToMultiByte(CP_ACP, 0, shortpathW, -1, shortpath, shortlen, NULL, NULL);
1340 ret--; /* length without 0 */
1341 }
1342 }
1343
1344 RtlFreeUnicodeString(&longpathW);
1345 return ret;
1346 }
1347
1348
1349 /***********************************************************************
1350 * GetLongPathNameW (KERNEL32.@)
1351 *
1352 * NOTES
1353 * observed (Win2000):
1354 * shortpath=NULL: LastError=ERROR_INVALID_PARAMETER, ret=0
1355 * shortpath="": LastError=ERROR_PATH_NOT_FOUND, ret=0
1356 */
1357 DWORD WINAPI GetLongPathNameW( LPCWSTR shortpath, LPWSTR longpath, DWORD longlen )
1358 {
1359 DOS_FULL_NAME full_name;
1360 const char *root;
1361 LPWSTR p;
1362 int drive;
1363 DWORD ret, len = 0;
1364
1365 if (!shortpath) {
1366 SetLastError(ERROR_INVALID_PARAMETER);
1367 return 0;
1368 }
1369 if (!shortpath[0]) {
1370 SetLastError(ERROR_PATH_NOT_FOUND);
1371 return 0;
1372 }
1373
1374 TRACE("%s,%p,%ld\n", debugstr_w(shortpath), longpath, longlen);
1375
1376 if(shortpath[0]=='\\' && shortpath[1]=='\\')
1377 {
1378 ERR("UNC pathname %s\n",debugstr_w(shortpath));
1379 lstrcpynW( longpath, full_name.short_name, longlen );
1380 return strlenW(longpath);
1381 }
1382
1383 if (!DOSFS_GetFullName( shortpath, TRUE, &full_name )) return 0;
1384
1385 root = full_name.long_name;
1386 drive = DRIVE_FindDriveRoot(&root);
1387
1388 ret = MultiByteToWideChar(CP_UNIXCP, 0, root, -1, NULL, 0);
1389 ret += 3; /* A:\ */
1390 /* reproduce terminating slash */
1391 if (ret > 4) /* if not drive root */
1392 {
1393 len = strlenW(shortpath);
1394 if (shortpath[len - 1] == '\\' || shortpath[len - 1] == '/')
1395 len = 1;
1396 }
1397 ret += len;
1398 if (ret <= longlen)
1399 {
1400 longpath[0] = 'A' + drive;
1401 longpath[1] = ':';
1402 MultiByteToWideChar(CP_UNIXCP, 0, root, -1, longpath + 2, longlen - 2);
1403 for (p = longpath; *p; p++) if (*p == '/') *p = '\\';
1404 if (len)
1405 {
1406 longpath[ret - 2] = '\\';
1407 longpath[ret - 1] = 0;
1408 }
1409 TRACE("returning %s\n", debugstr_w(longpath));
1410 ret--; /* length without 0 */
1411 }
1412 return ret;
1413 }
1414
1415
1416 /***********************************************************************
1417 * GetLongPathNameA (KERNEL32.@)
1418 */
1419 DWORD WINAPI GetLongPathNameA( LPCSTR shortpath, LPSTR longpath, DWORD longlen )
1420 {
1421 UNICODE_STRING shortpathW;
1422 WCHAR longpathW[MAX_PATH];
1423 DWORD ret, retW;
1424
1425 if (!shortpath)
1426 {
1427 SetLastError(ERROR_INVALID_PARAMETER);
1428 return 0;
1429 }
1430
1431 TRACE("%s\n", debugstr_a(shortpath));
1432
1433 if (!RtlCreateUnicodeStringFromAsciiz(&shortpathW, shortpath))
1434 {
1435 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1436 return 0;
1437 }
1438
1439 retW = GetLongPathNameW(shortpathW.Buffer, longpathW, MAX_PATH);
1440
1441 if (!retW)
1442 ret = 0;
1443 else if (retW > MAX_PATH)
1444 {
1445 SetLastError(ERROR_FILENAME_EXCED_RANGE);
1446 ret = 0;
1447 }
1448 else
1449 {
1450 ret = WideCharToMultiByte(CP_ACP, 0, longpathW, -1, NULL, 0, NULL, NULL);
1451 if (ret <= longlen)
1452 {
1453 WideCharToMultiByte(CP_ACP, 0, longpathW, -1, longpath, longlen, NULL, NULL);
1454 ret--; /* length without 0 */
1455 }
1456 }
1457
1458 RtlFreeUnicodeString(&shortpathW);
1459 return ret;
1460 }
1461
1462
1463 /***********************************************************************
1464 * DOSFS_DoGetFullPathName
1465 *
1466 * Implementation of GetFullPathNameA/W.
1467 *
1468 * bon@elektron 000331:
1469 * A test for GetFullPathName with many pathological cases
1470 * now gives identical output for Wine and OSR2
1471 */
1472 static DWORD DOSFS_DoGetFullPathName( LPCWSTR name, DWORD len, LPWSTR result )
1473 {
1474 DWORD ret;
1475 DOS_FULL_NAME full_name;
1476 LPWSTR p, q;
1477 char *p_l;
1478 const char * root;
1479 WCHAR drivecur[] = {'C',':','.',0};
1480 WCHAR driveletter=0;
1481 int namelen,drive=0;
1482 static const WCHAR bkslashW[] = {'\\',0};
1483 static const WCHAR dotW[] = {'.',0};
1484 static const WCHAR updir_slashW[] = {'\\','.','.','\\',0};
1485 static const WCHAR curdirW[] = {'\\','.','\\',0};
1486 static const WCHAR updirW[] = {'\\','.','.',0};
1487
1488 if (!name[0])
1489 {
1490 SetLastError(ERROR_BAD_PATHNAME);
1491 return 0;
1492 }
1493
1494 TRACE("passed %s\n", debugstr_w(name));
1495
1496 if (name[1]==':')
1497 /*drive letter given */
1498 {
1499 driveletter = name[0];
1500 }
1501 if ((name[1]==':') && ((name[2]=='\\') || (name[2]=='/')))
1502 /*absolute path given */
1503 {
1504 strncpyW(full_name.short_name, name, MAX_PATHNAME_LEN);
1505 full_name.short_name[MAX_PATHNAME_LEN - 1] = 0; /* ensure 0 termination */
1506 drive = toupperW(name[0]) - 'A';
1507 }
1508 else
1509 {
1510 if (driveletter)
1511 drivecur[0]=driveletter;
1512 else if ((name[0]=='\\') || (name[0]=='/'))
1513 strcpyW(drivecur, bkslashW);
1514 else
1515 strcpyW(drivecur, dotW);
1516
1517 if (!DOSFS_GetFullName( drivecur, FALSE, &full_name ))
1518 {
1519 FIXME("internal: error getting drive/path\n");
1520 return 0;
1521 }
1522 /* find path that drive letter substitutes*/
1523 drive = toupperW(full_name.short_name[0]) - 'A';
1524 root= DRIVE_GetRoot(drive);
1525 if (!root)
1526 {
1527 FIXME("internal: error getting DOS Drive Root\n");
1528 return 0;
1529 }
1530 if (!strcmp(root,"/"))
1531 {
1532 /* we have just the last / and we need it. */
1533 p_l = full_name.long_name;
1534 }
1535 else
1536 {
1537 p_l = full_name.long_name + strlen(root);
1538 }
1539 /* append long name (= unix name) to drive */
1540 MultiByteToWideChar(CP_UNIXCP, 0, p_l, -1, full_name.short_name + 2, MAX_PATHNAME_LEN - 3);
1541 /* append name to treat */
1542 namelen= strlenW(full_name.short_name);
1543 p = (LPWSTR)name;
1544 if (driveletter)
1545 p += 2; /* skip drive name when appending */
1546 if (namelen + 2 + strlenW(p) > MAX_PATHNAME_LEN)
1547 {
1548 FIXME("internal error: buffer too small\n");
1549 return 0;
1550 }
1551 full_name.short_name[namelen++] ='\\';
1552 full_name.short_name[namelen] = 0;
1553 strncpyW(full_name.short_name + namelen, p, MAX_PATHNAME_LEN - namelen);
1554 full_name.short_name[MAX_PATHNAME_LEN - 1] = 0; /* ensure 0 termination */
1555 }
1556 /* reverse all slashes */
1557 for (p=full_name.short_name;
1558 p < full_name.short_name + strlenW(full_name.short_name);
1559 p++)
1560 {
1561 if ( *p == '/' )
1562 *p = '\\';
1563 }
1564 /* Use memmove, as areas overlap */
1565 /* Delete .. */
1566 while ((p = strstrW(full_name.short_name, updir_slashW)))
1567 {
1568 if (p > full_name.short_name+2)
1569 {
1570 *p = 0;
1571 q = strrchrW(full_name.short_name, '\\');
1572 memmove(q+1, p+4, (strlenW(p+4)+1) * sizeof(WCHAR));
1573 }
1574 else
1575 {
1576 memmove(full_name.short_name+3, p+4, (strlenW(p+4)+1) * sizeof(WCHAR));
1577 }
1578 }
1579 if ((full_name.short_name[2]=='.')&&(full_name.short_name[3]=='.'))
1580 {
1581 /* This case istn't treated yet : c:..\test */
1582 memmove(full_name.short_name+2,full_name.short_name+4,
1583 (strlenW(full_name.short_name+4)+1) * sizeof(WCHAR));
1584 }
1585 /* Delete . */
1586 while ((p = strstrW(full_name.short_name, curdirW)))
1587 {
1588 *(p+1) = 0;
1589 memmove(p+1, p+3, (strlenW(p+3)+1) * sizeof(WCHAR));
1590 }
1591 if (!(DRIVE_GetFlags(drive) & DRIVE_CASE_PRESERVING))
1592 for (p = full_name.short_name; *p; p++) *p = toupperW(*p);
1593 namelen = strlenW(full_name.short_name);
1594 if (!strcmpW(full_name.short_name+namelen-3, updirW))
1595 {
1596 /* one more strange case: "c:\test\test1\.."
1597 return "c:\test" */
1598 *(full_name.short_name+namelen-3)=0;
1599 q = strrchrW(full_name.short_name, '\\');
1600 *q =0;
1601 }
1602 if (full_name.short_name[namelen-1]=='.')
1603 full_name.short_name[(namelen--)-1] =0;
1604 if (!driveletter)
1605 if (full_name.short_name[namelen-1]=='\\')
1606 full_name.short_name[(namelen--)-1] =0;
1607 TRACE("got %s\n", debugstr_w(full_name.short_name));
1608
1609 /* If the lpBuffer buffer is too small, the return value is the
1610 size of the buffer, in characters, required to hold the path
1611 plus the terminating \0 (tested against win95osr2, bon 001118)
1612 . */
1613 ret = strlenW(full_name.short_name);
1614 if (ret >= len )
1615 {
1616 /* don't touch anything when the buffer is not large enough */
1617 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1618 return ret+1;
1619 }
1620 if (result)
1621 {
1622 strncpyW( result, full_name.short_name, len );
1623 result[len - 1] = 0; /* ensure 0 termination */
1624 }
1625
1626 TRACE("returning %s\n", debugstr_w(full_name.short_name) );
1627 return ret;
1628 }
1629
1630
1631 /***********************************************************************
1632 * GetFullPathNameA (KERNEL32.@)
1633 * NOTES
1634 * if the path closed with '\', *lastpart is 0
1635 */
1636 DWORD WINAPI GetFullPathNameA( LPCSTR name, DWORD len, LPSTR buffer,
1637 LPSTR *lastpart )
1638 {
1639 UNICODE_STRING nameW;
1640 WCHAR bufferW[MAX_PATH];
1641 DWORD ret, retW;
1642
1643 if (!name)
1644 {
1645 SetLastError(ERROR_INVALID_PARAMETER);
1646 return 0;
1647 }
1648
1649 if (!RtlCreateUnicodeStringFromAsciiz(&nameW, name))
1650 {
1651 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1652 return 0;
1653 }
1654
1655 retW = GetFullPathNameW( nameW.Buffer, MAX_PATH, bufferW, NULL);
1656
1657 if (!retW)
1658 ret = 0;
1659 else if (retW > MAX_PATH)
1660 {
1661 SetLastError(ERROR_FILENAME_EXCED_RANGE);
1662 ret = 0;
1663 }
1664 else
1665 {
1666 ret = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
1667 if (ret <= len)
1668 {
1669 WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, len, NULL, NULL);
1670 ret--; /* length without 0 */
1671
1672 if (lastpart)
1673 {
1674 LPSTR p = buffer + strlen(buffer);
1675
1676 if (*p != '\\')
1677 {
1678 while ((p > buffer + 2) && (*p != '\\')) p--;
1679 *lastpart = p + 1;
1680 }
1681 else *lastpart = NULL;
1682 }
1683 }
1684 }
1685
1686 RtlFreeUnicodeString(&nameW);
1687 return ret;
1688 }
1689
1690
1691 /***********************************************************************
1692 * GetFullPathNameW (KERNEL32.@)
1693 */
1694 DWORD WINAPI GetFullPathNameW( LPCWSTR name, DWORD len, LPWSTR buffer,
1695 LPWSTR *lastpart )
1696 {
1697 DWORD ret = DOSFS_DoGetFullPathName( name, len, buffer );
1698 if (ret && (ret<=len) && buffer && lastpart)
1699 {
1700 LPWSTR p = buffer + strlenW(buffer);
1701 if (*p != (WCHAR)'\\')
1702 {
1703 while ((p > buffer + 2) && (*p != (WCHAR)'\\')) p--;
1704 *lastpart = p + 1;
1705 }
1706 else *lastpart = NULL;
1707 }
1708 return ret;
1709 }
1710
1711
1712 /***********************************************************************
1713 * wine_get_unix_file_name (KERNEL32.@) Not a Windows API
1714 *
1715 * Return the full Unix file name for a given path.
1716 * FIXME: convert dos file name to unicode
1717 */
1718 BOOL WINAPI wine_get_unix_file_name( LPCSTR dos, LPSTR buffer, DWORD len )
1719 {
1720 BOOL ret;
1721 DOS_FULL_NAME path;
1722 WCHAR dosW[MAX_PATHNAME_LEN];
1723
1724 MultiByteToWideChar(CP_ACP, 0, dos, -1, dosW, MAX_PATHNAME_LEN);
1725 ret = DOSFS_GetFullName( dosW, FALSE, &path );
1726 if (ret && len)
1727 {
1728 strncpy( buffer, path.long_name, len );
1729 buffer[len - 1] = 0; /* ensure 0 termination */
1730 }
1731 return ret;
1732 }
1733
1734
1735 /***********************************************************************
1736 * get_show_dir_symlinks_option
1737 */
1738 static BOOL get_show_dir_symlinks_option(void)
1739 {
1740 static const WCHAR WineW[] = {'M','a','c','h','i','n','e','\\',
1741 'S','o','f','t','w','a','r','e','\\',
1742 'W','i','n','e','\\','W','i','n','e','\\',
1743 'C','o','n','f','i','g','\\','W','i','n','e',0};
1744 static const WCHAR ShowDirSymlinksW[] = {'S','h','o','w','D','i','r','S','y','m','l','i','n','k','s',0};
1745
1746 char tmp[80];
1747 HKEY hkey;
1748 DWORD dummy;
1749 OBJECT_ATTRIBUTES attr;
1750 UNICODE_STRING nameW;
1751 BOOL ret = FALSE;
1752
1753 attr.Length = sizeof(attr);
1754 attr.RootDirectory = 0;
1755 attr.ObjectName = &nameW;
1756 attr.Attributes = 0;
1757 attr.SecurityDescriptor = NULL;
1758 attr.SecurityQualityOfService = NULL;
1759 RtlInitUnicodeString( &nameW, WineW );
1760
1761 if (!NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ))
1762 {
1763 RtlInitUnicodeString( &nameW, ShowDirSymlinksW );
1764 if (!NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, tmp, sizeof(tmp), &dummy ))
1765 {
1766 WCHAR *str = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)tmp)->Data;
1767 ret = IS_OPTION_TRUE( str[0] );
1768 }
1769 NtClose( hkey );
1770 }
1771 return ret;
1772 }
1773
1774
1775 /***********************************************************************
1776 * DOSFS_FindNextEx
1777 */
1778 static int DOSFS_FindNextEx( FIND_FIRST_INFO *info, WIN32_FIND_DATAW *entry )
1779 {
1780 DWORD attr = info->attr | FA_UNUSED | FA_ARCHIVE | FA_RDONLY;
1781 UINT flags = DRIVE_GetFlags( info->drive );
1782 char *p, buffer[MAX_PATHNAME_LEN];
1783 const char *drive_path;
1784 int drive_root;
1785 LPCWSTR long_name, short_name;
1786 BY_HANDLE_FILE_INFORMATION fileinfo;
1787 WCHAR dos_name[13];
1788 BOOL is_symlink;
1789
1790 if ((info->attr & ~(FA_UNUSED | FA_ARCHIVE | FA_RDONLY)) == FA_LABEL)
1791 {
1792 if (info->cur_pos) return 0;
1793 entry->dwFileAttributes = FILE_ATTRIBUTE_LABEL;
1794 RtlSecondsSince1970ToTime( (time_t)0, (LARGE_INTEGER *)&entry->ftCreationTime );
1795 RtlSecondsSince1970ToTime( (time_t)0, (LARGE_INTEGER *)&entry->ftLastAccessTime );
1796 RtlSecondsSince1970ToTime( (time_t)0, (LARGE_INTEGER *)&entry->ftLastWriteTime );
1797 entry->nFileSizeHigh = 0;
1798 entry->nFileSizeLow = 0;
1799 entry->dwReserved0 = 0;
1800 entry->dwReserved1 = 0;
1801 DOSFS_ToDosDTAFormat( DRIVE_GetLabel( info->drive ), entry->cFileName );
1802 strcpyW( entry->cAlternateFileName, entry->cFileName );
1803 info->cur_pos++;
1804 TRACE("returning %s (%s) as label\n",
1805 debugstr_w(entry->cFileName), debugstr_w(entry->cAlternateFileName));
1806 return 1;
1807 }
1808
1809 drive_path = info->path + strlen(DRIVE_GetRoot( info->drive ));
1810 while ((*drive_path == '/') || (*drive_path == '\\')) drive_path++;
1811 drive_root = !*drive_path;
1812
1813 lstrcpynA( buffer, info->path, sizeof(buffer) - 1 );
1814 strcat( buffer, "/" );
1815 p = buffer + strlen(buffer);
1816
1817 while (DOSFS_ReadDir( info->u.dos_dir, &long_name, &short_name ))
1818 {
1819 info->cur_pos++;
1820
1821 /* Don't return '.' and '..' in the root of the drive */
1822 if (drive_root && (long_name[0] == '.') &&
1823 (!long_name[1] || ((long_name[1] == '.') && !long_name[2])))
1824 continue;
1825
1826 /* Check the long mask */
1827
1828 if (info->long_mask && *info->long_mask)
1829 {
1830 if (!DOSFS_MatchLong( info->long_mask, long_name,
1831 flags & DRIVE_CASE_SENSITIVE )) continue;
1832 }
1833
1834 /* Check the short mask */
1835
1836 if (info->short_mask)
1837 {
1838 if (!short_name)
1839 {
1840 DOSFS_Hash( long_name, dos_name, TRUE,
1841 !(flags & DRIVE_CASE_SENSITIVE) );
1842 short_name = dos_name;
1843 }
1844 if (!DOSFS_MatchShort( info->short_mask, short_name )) continue;
1845 }
1846
1847 /* Check the file attributes */
1848 WideCharToMultiByte(CP_UNIXCP, 0, long_name, -1,
1849 p, sizeof(buffer) - (int)(p - buffer), NULL, NULL);
1850 if (!FILE_Stat( buffer, &fileinfo, &is_symlink ))
1851 {
1852 WARN("can't stat %s\n", buffer);
1853 continue;
1854 }
1855 if (is_symlink && (fileinfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
1856 {
1857 static int show_dir_symlinks = -1;
1858 if (show_dir_symlinks == -1)
1859 show_dir_symlinks = get_show_dir_symlinks_option();
1860 if (!show_dir_symlinks) continue;
1861 }
1862
1863 if (fileinfo.dwFileAttributes & ~attr) continue;
1864
1865 /* We now have a matching entry; fill the result and return */
1866
1867 entry->dwFileAttributes = fileinfo.dwFileAttributes;
1868 entry->ftCreationTime = fileinfo.ftCreationTime;
1869 entry->ftLastAccessTime = fileinfo.ftLastAccessTime;
1870 entry->ftLastWriteTime = fileinfo.ftLastWriteTime;
1871 entry->nFileSizeHigh = fileinfo.nFileSizeHigh;
1872 entry->nFileSizeLow = fileinfo.nFileSizeLow;
1873
1874 if (short_name)
1875 DOSFS_ToDosDTAFormat( short_name, entry->cAlternateFileName );
1876 else
1877 DOSFS_Hash( long_name, entry->cAlternateFileName, FALSE,
1878 !(flags & DRIVE_CASE_SENSITIVE) );
1879
1880 lstrcpynW( entry->cFileName, long_name, sizeof(entry->cFileName)/sizeof(entry->cFileName[0]) );
1881 if (!(flags & DRIVE_CASE_PRESERVING)) strlwrW( entry->cFileName );
1882 TRACE("returning %s (%s) %02lx %ld\n",
1883 debugstr_w(entry->cFileName), debugstr_w(entry->cAlternateFileName),
1884 entry->dwFileAttributes, entry->nFileSizeLow );
1885 return 1;
1886 }
1887 return 0; /* End of directory */
1888 }
1889
1890 /***********************************************************************
1891 * DOSFS_FindNext
1892 *
1893 * Find the next matching file. Return the number of entries read to find
1894 * the matching one, or 0 if no more entries.
1895 * 'short_mask' is the 8.3 mask (in FCB format), 'long_mask' is the long
1896 * file name mask. Either or both can be NULL.
1897 *
1898 * NOTE: This is supposed to be only called by the int21 emulation
1899 * routines, and so assumes that the Win16Mutex is held to
1900 * protect the static directory cache.
1901 */
1902 int DOSFS_FindNext( const char *path, const char *short_mask,
1903 const char *long_mask, int drive, BYTE attr,
1904 int skip, WIN32_FIND_DATAA *entry )
1905 {
1906 static FIND_FIRST_INFO info;
1907 LPCWSTR short_name, long_name;
1908 int count;
1909 UNICODE_STRING short_maskW, long_maskW;
1910 WIN32_FIND_DATAW entryW;
1911
1912 TRACE("(%s, %s, %s, %x, %x, %x, %p)\n", debugstr_a(path),
1913 debugstr_a(short_mask), debugstr_a(long_mask), drive, attr, skip,
1914 entry);
1915
1916 RtlCreateUnicodeStringFromAsciiz(&short_maskW, short_mask);
1917 RtlCreateUnicodeStringFromAsciiz(&long_maskW, long_mask);
1918
1919 /* Check the cached directory */
1920 if (!(info.u.dos_dir && info.path == path && !strcmpW(info.short_mask, short_maskW.Buffer)
1921 && !strcmpW(info.long_mask, long_maskW.Buffer) && info.drive == drive
1922 && info.attr == attr && info.cur_pos <= skip))
1923 {
1924 /* Not in the cache, open it anew */
1925 if (info.u.dos_dir) DOSFS_CloseDir( info.u.dos_dir );
1926
1927 info.path = (LPSTR)path;
1928 RtlFreeHeap(GetProcessHeap(), 0, info.long_mask);
1929 RtlFreeHeap(GetProcessHeap(), 0, info.short_mask);
1930 info.long_mask = long_maskW.Buffer;
1931 info.short_mask = short_maskW.Buffer;
1932 info.attr = attr;
1933 info.drive = drive;
1934 info.cur_pos = 0;
1935 info.u.dos_dir = DOSFS_OpenDir( info.path );
1936 }
1937 else
1938 {
1939 RtlFreeUnicodeString(&short_maskW);
1940 RtlFreeUnicodeString(&long_maskW);
1941 }
1942
1943 /* Skip to desired position */
1944 while (info.cur_pos < skip)
1945 if (info.u.dos_dir && DOSFS_ReadDir( info.u.dos_dir, &long_name, &short_name ))
1946 info.cur_pos++;
1947 else
1948 break;
1949
1950 if (info.u.dos_dir && info.cur_pos == skip && DOSFS_FindNextEx( &info, &entryW ))
1951 {
1952 WideCharToMultiByte(CP_ACP, 0, entryW.cFileName, -1,
1953 entry->cFileName, sizeof(entry->cFileName), NULL, NULL);
1954 WideCharToMultiByte(CP_ACP, 0, entryW.cAlternateFileName, -1,
1955 entry->cAlternateFileName, sizeof(entry->cAlternateFileName), NULL, NULL);
1956 count = info.cur_pos - skip;
1957
1958 entry->dwFileAttributes = entryW.dwFileAttributes;
1959 entry->nFileSizeHigh = entryW.nFileSizeHigh;
1960 entry->nFileSizeLow = entryW.nFileSizeLow;
1961 entry->ftCreationTime = entryW.ftCreationTime;
1962 entry->ftLastAccessTime = entryW.ftLastAccessTime;
1963 entry->ftLastWriteTime = entryW.ftLastWriteTime;
1964
1965 }
1966 else
1967 count = 0;
1968
1969 if (!count)
1970 {
1971 if (info.u.dos_dir) DOSFS_CloseDir( info.u.dos_dir );
1972 memset( &info, '\0', sizeof(info) );
1973 }
1974
1975 return count;
1976 }
1977
1978 /*************************************************************************
1979 * FindFirstFileExW (KERNEL32.@)
1980 */
1981 HANDLE WINAPI FindFirstFileExW(
1982 LPCWSTR lpFileName,
1983 FINDEX_INFO_LEVELS fInfoLevelId,
1984 LPVOID lpFindFileData,
1985 FINDEX_SEARCH_OPS fSearchOp,
1986 LPVOID lpSearchFilter,
1987 DWORD dwAdditionalFlags)
1988 {
1989 FIND_FIRST_INFO *info;
1990
1991 if (!lpFileName)
1992 {
1993 SetLastError(ERROR_PATH_NOT_FOUND);
1994 return INVALID_HANDLE_VALUE;
1995 }
1996
1997 if ((fSearchOp != FindExSearchNameMatch) || (dwAdditionalFlags != 0))
1998 {
1999 FIXME("options not implemented 0x%08x 0x%08lx\n", fSearchOp, dwAdditionalFlags );
2000 return INVALID_HANDLE_VALUE;
2001 }
2002
2003 switch(fInfoLevelId)
2004 {
2005 case FindExInfoStandard:
2006 {
2007 WIN32_FIND_DATAW * data = (WIN32_FIND_DATAW *) lpFindFileData;
2008 char *p;
2009 INT long_mask_len;
2010
2011 data->dwReserved0 = data->dwReserved1 = 0x0;
2012 if (lpFileName[0] == '\\' && lpFileName[1] == '\\')
2013 {
2014 ERR("UNC path name\n");
2015 if (!(info = HeapAlloc( GetProcessHeap(), 0, sizeof(FIND_FIRST_INFO)))) break;
2016 info->u.smb_dir = SMB_FindFirst(lpFileName);
2017 if(!info->u.smb_dir)
2018 {
2019 HeapFree(GetProcessHeap(), 0, info);
2020 break;
2021 }
2022 info->drive = -1;
2023 RtlInitializeCriticalSection( &info->cs );
2024 }
2025 else
2026 {
2027 DOS_FULL_NAME full_name;
2028
2029 if (lpFileName[0] && lpFileName[1] == ':')
2030 {
2031 /* don't allow root directories */
2032 if (!lpFileName[2] ||
2033 ((lpFileName[2] == '/' || lpFileName[2] == '\\') && !lpFileName[3]))
2034 {
2035 SetLastError(ERROR_FILE_NOT_FOUND);
2036 return INVALID_HANDLE_VALUE;
2037 }
2038 }
2039 if (!DOSFS_GetFullName( lpFileName, FALSE, &full_name )) break;
2040 if (!(info = HeapAlloc( GetProcessHeap(), 0, sizeof(FIND_FIRST_INFO)))) break;
2041 RtlInitializeCriticalSection( &info->cs );
2042 info->path = HeapAlloc( GetProcessHeap(), 0, strlen(full_name.long_name)+1 );
2043 strcpy( info->path, full_name.long_name );
2044
2045 p = strrchr( info->path, '/' );
2046 *p++ = '\0';
2047 long_mask_len = MultiByteToWideChar(CP_UNIXCP, 0, p, -1, NULL, 0);
2048 info->long_mask = HeapAlloc( GetProcessHeap(), 0, long_mask_len * sizeof(WCHAR) );
2049 MultiByteToWideChar(CP_UNIXCP, 0, p, -1, info->long_mask, long_mask_len);
2050
2051 info->short_mask = NULL;
2052 info->attr = 0xff;
2053 info->drive = full_name.drive;
2054 info->cur_pos = 0;
2055
2056 info->u.dos_dir = DOSFS_OpenDir( info->path );
2057 }
2058 if (!FindNextFileW( (HANDLE) info, data ))
2059 {
2060 FindClose( (HANDLE) info );
2061 SetLastError( ERROR_FILE_NOT_FOUND );
2062 break;
2063 }
2064 return (HANDLE) info;
2065 }
2066 break;
2067 default:
2068 FIXME("fInfoLevelId 0x%08x not implemented\n", fInfoLevelId );
2069 }
2070 return INVALID_HANDLE_VALUE;
2071 }
2072
2073 /*************************************************************************
2074 * FindFirstFileA (KERNEL32.@)
2075 */
2076 HANDLE WINAPI FindFirstFileA(
2077 LPCSTR lpFileName,
2078 WIN32_FIND_DATAA *lpFindData )
2079 {
2080 return FindFirstFileExA(lpFileName, FindExInfoStandard, lpFindData,
2081 FindExSearchNameMatch, NULL, 0);
2082 }
2083
2084 /*************************************************************************
2085 * FindFirstFileExA (KERNEL32.@)
2086 */
2087 HANDLE WINAPI FindFirstFileExA(
2088 LPCSTR lpFileName,
2089 FINDEX_INFO_LEVELS fInfoLevelId,
2090 LPVOID lpFindFileData,
2091 FINDEX_SEARCH_OPS fSearchOp,
2092 LPVOID lpSearchFilter,
2093 DWORD dwAdditionalFlags)
2094 {
2095 HANDLE handle;
2096 WIN32_FIND_DATAA *dataA;
2097 WIN32_FIND_DATAW dataW;
2098 UNICODE_STRING pathW;
2099
2100 if (!lpFileName)
2101 {
2102 SetLastError(ERROR_PATH_NOT_FOUND);
2103 return INVALID_HANDLE_VALUE;
2104 }
2105
2106 if (!RtlCreateUnicodeStringFromAsciiz(&pathW, lpFileName))
2107 {
2108 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2109 return INVALID_HANDLE_VALUE;
2110 }
2111
2112 handle = FindFirstFileExW(pathW.Buffer, fInfoLevelId, &dataW, fSearchOp, lpSearchFilter, dwAdditionalFlags);
2113 RtlFreeUnicodeString(&pathW);
2114 if (handle == INVALID_HANDLE_VALUE) return handle;
2115
2116 dataA = (WIN32_FIND_DATAA *) lpFindFileData;
2117 dataA->dwFileAttributes = dataW.dwFileAttributes;
2118 dataA->ftCreationTime = dataW.ftCreationTime;
2119 dataA->ftLastAccessTime = dataW.ftLastAccessTime;
2120 dataA->ftLastWriteTime = dataW.ftLastWriteTime;
2121 dataA->nFileSizeHigh = dataW.nFileSizeHigh;
2122 dataA->nFileSizeLow = dataW.nFileSizeLow;
2123 WideCharToMultiByte( CP_ACP, 0, dataW.cFileName, -1,
2124 dataA->cFileName, sizeof(dataA->cFileName), NULL, NULL );
2125 WideCharToMultiByte( CP_ACP, 0, dataW.cAlternateFileName, -1,
2126 dataA->cAlternateFileName, sizeof(dataA->cAlternateFileName), NULL, NULL );
2127 return handle;
2128 }
2129
2130 /*************************************************************************
2131 * FindFirstFileW (KERNEL32.@)
2132 */
2133 HANDLE WINAPI FindFirstFileW( LPCWSTR lpFileName, WIN32_FIND_DATAW *lpFindData )
2134 {
2135 return FindFirstFileExW(lpFileName, FindExInfoStandard, lpFindData,
2136 FindExSearchNameMatch, NULL, 0);
2137 }
2138
2139 /*************************************************************************
2140 * FindNextFileW (KERNEL32.@)
2141 */
2142 BOOL WINAPI FindNextFileW( HANDLE handle, WIN32_FIND_DATAW *data )
2143 {
2144 FIND_FIRST_INFO *info;
2145 BOOL ret = FALSE;
2146 DWORD gle = ERROR_NO_MORE_FILES;
2147
2148 if (handle == INVALID_HANDLE_VALUE)
2149 {
2150 SetLastError( ERROR_INVALID_HANDLE );
2151 return ret;
2152 }
2153 info = (FIND_FIRST_INFO*) handle;
2154 RtlEnterCriticalSection( &info->cs );
2155 if (info->drive == -1)
2156 {
2157 ret = SMB_FindNext( info->u.smb_dir, data );
2158 if(!ret)
2159 {
2160 SMB_CloseDir( info->u.smb_dir );
2161 HeapFree( GetProcessHeap(), 0, info->path );
2162 }
2163 goto done;
2164 }
2165 else if (!info->path || !info->u.dos_dir)
2166 {
2167 goto done;
2168 }
2169 else if (!DOSFS_FindNextEx( info, data ))
2170 {
2171 DOSFS_CloseDir( info->u.dos_dir ); info->u.dos_dir = NULL;
2172 HeapFree( GetProcessHeap(), 0, info->path );
2173 info->path = NULL;
2174 HeapFree( GetProcessHeap(), 0, info->long_mask );
2175 info->long_mask = NULL;
2176 goto done;
2177 }
2178 ret = TRUE;
2179 done:
2180 RtlLeaveCriticalSection( &info->cs );
2181 if( !ret ) SetLastError( gle );
2182 return ret;
2183 }
2184
2185
2186 /*************************************************************************
2187 * FindNextFileA (KERNEL32.@)
2188 */
2189 BOOL WINAPI FindNextFileA( HANDLE handle, WIN32_FIND_DATAA *data )
2190 {
2191 WIN32_FIND_DATAW dataW;
2192 if (!FindNextFileW( handle, &dataW )) return FALSE;
2193 data->dwFileAttributes = dataW.dwFileAttributes;
2194 data->ftCreationTime = dataW.ftCreationTime;
2195 data->ftLastAccessTime = dataW.ftLastAccessTime;
2196 data->ftLastWriteTime = dataW.ftLastWriteTime;
2197 data->nFileSizeHigh = dataW.nFileSizeHigh;
2198 data->nFileSizeLow = dataW.nFileSizeLow;
2199 WideCharToMultiByte( CP_ACP, 0, dataW.cFileName, -1,
2200 data->cFileName, sizeof(data->cFileName), NULL, NULL );
2201 WideCharToMultiByte( CP_ACP, 0, dataW.cAlternateFileName, -1,
2202 data->cAlternateFileName,
2203 sizeof(data->cAlternateFileName), NULL, NULL );
2204 return TRUE;
2205 }
2206
2207 /*************************************************************************
2208 * FindClose (KERNEL32.@)
2209 */
2210 BOOL WINAPI FindClose( HANDLE handle )
2211 {
2212 FIND_FIRST_INFO *info = (FIND_FIRST_INFO*) handle;
2213
2214 if (handle == INVALID_HANDLE_VALUE) goto error;
2215
2216 __TRY
2217 {
2218 RtlEnterCriticalSection( &info->cs );
2219 if (info)
2220 {
2221 if (info->u.dos_dir) DOSFS_CloseDir( info->u.dos_dir );
2222 if (info->path) HeapFree( GetProcessHeap(), 0, info->path );
2223 if (info->long_mask) HeapFree( GetProcessHeap(), 0, info->long_mask );
2224 }
2225 }
2226 __EXCEPT(page_fault)
2227 {
2228 WARN("Illegal handle %p\n", handle);
2229 SetLastError( ERROR_INVALID_HANDLE );
2230 return FALSE;
2231 }
2232 __ENDTRY
2233 if (!info) goto error;
2234 RtlLeaveCriticalSection( &info->cs );
2235 RtlDeleteCriticalSection( &info->cs );
2236 HeapFree(GetProcessHeap(), 0, info);
2237 return TRUE;
2238
2239 error:
2240 SetLastError( ERROR_INVALID_HANDLE );
2241 return FALSE;
2242 }
2243
2244 /***********************************************************************
2245 * MulDiv (KERNEL32.@)
2246 * RETURNS
2247 * Result of multiplication and division
2248 * -1: Overflow occurred or Divisor was 0
2249 */
2250 INT WINAPI MulDiv(
2251 INT nMultiplicand,
2252 INT nMultiplier,
2253 INT nDivisor)
2254 {
2255 #if SIZEOF_LONG_LONG >= 8
2256 long long ret;
2257
2258 if (!nDivisor) return -1;
2259
2260 /* We want to deal with a positive divisor to simplify the logic. */
2261 if (nDivisor < 0)
2262 {
2263 nMultiplicand = - nMultiplicand;
2264 nDivisor = -nDivisor;
2265 }
2266
2267 /* If the result is positive, we "add" to round. else, we subtract to round. */
2268 if ( ( (nMultiplicand < 0) && (nMultiplier < 0) ) ||
2269 ( (nMultiplicand >= 0) && (nMultiplier >= 0) ) )
2270 ret = (((long long)nMultiplicand * nMultiplier) + (nDivisor/2)) / nDivisor;
2271 else
2272 ret = (((long long)nMultiplicand * nMultiplier) - (nDivisor/2)) / nDivisor;
2273
2274 if ((ret > 2147483647) || (ret < -2147483647)) return -1;
2275 return ret;
2276 #else
2277 if (!nDivisor) return -1;
2278
2279 /* We want to deal with a positive divisor to simplify the logic. */
2280 if (nDivisor < 0)
2281 {
2282 nMultiplicand = - nMultiplicand;
2283 nDivisor = -nDivisor;
2284 }
2285
2286 /* If the result is positive, we "add" to round. else, we subtract to round. */
2287 if ( ( (nMultiplicand < 0) && (nMultiplier < 0) ) ||
2288 ( (nMultiplicand >= 0) && (nMultiplier >= 0) ) )
2289 return ((nMultiplicand * nMultiplier) + (nDivisor/2)) / nDivisor;
2290
2291 return ((nMultiplicand * nMultiplier) - (nDivisor/2)) / nDivisor;
2292
2293 #endif
2294 }
2295
2296
2297 /***********************************************************************
2298 * DosDateTimeToFileTime (KERNEL32.@)
2299 */
2300 BOOL WINAPI DosDateTimeToFileTime( WORD fatdate, WORD fattime, LPFILETIME ft)
2301 {
2302 struct tm newtm;
2303 #ifndef HAVE_TIMEGM
2304 struct tm *gtm;
2305 time_t time1, time2;
2306 #endif
2307
2308 newtm.tm_sec = (fattime & 0x1f) * 2;
2309 newtm.tm_min = (fattime >> 5) & 0x3f;
2310 newtm.tm_hour = (fattime >> 11);
2311 newtm.tm_mday = (fatdate & 0x1f);
2312 newtm.tm_mon = ((fatdate >> 5) & 0x0f) - 1;
2313 newtm.tm_year = (fatdate >> 9) + 80;
2314 #ifdef HAVE_TIMEGM
2315 RtlSecondsSince1970ToTime( timegm(&newtm), (LARGE_INTEGER *)ft );
2316 #else
2317 time1 = mktime(&newtm);
2318 gtm = gmtime(&time1);
2319 time2 = mktime(gtm);
2320 RtlSecondsSince1970ToTime( 2*time1-time2, (LARGE_INTEGER *)ft );
2321 #endif
2322 return TRUE;
2323 }
2324
2325
2326 /***********************************************************************
2327 * FileTimeToDosDateTime (KERNEL32.@)
2328 */
2329 BOOL WINAPI FileTimeToDosDateTime( const FILETIME *ft, LPWORD fatdate,
2330 LPWORD fattime )
2331 {
2332 LARGE_INTEGER li;
2333 ULONG t;
2334 time_t unixtime;
2335 struct tm* tm;
2336
2337 li.s.LowPart = ft->dwLowDateTime;
2338 li.s.HighPart = ft->dwHighDateTime;
2339 RtlTimeToSecondsSince1970( &li, &t );
2340 unixtime = t;
2341 tm = gmtime( &unixtime );
2342 if (fattime)
2343 *fattime = (tm->tm_hour << 11) + (tm->tm_min << 5) + (tm->tm_sec / 2);
2344 if (fatdate)
2345 *fatdate = ((tm->tm_year - 80) << 9) + ((tm->tm_mon + 1) << 5)
2346 + tm->tm_mday;
2347 return TRUE;
2348 }
2349
2350
2351 /***********************************************************************
2352 * QueryDosDeviceA (KERNEL32.@)
2353 *
2354 * returns array of strings terminated by \0, terminated by \0
2355 */
2356 DWORD WINAPI QueryDosDeviceA(LPCSTR devname,LPSTR target,DWORD bufsize)
2357 {
2358 DWORD ret = 0, retW;
2359 LPWSTR targetW = (LPWSTR)HeapAlloc(GetProcessHeap(),0,
2360 bufsize * sizeof(WCHAR));
2361 UNICODE_STRING devnameW;
2362
2363 if(devname) RtlCreateUnicodeStringFromAsciiz(&devnameW, devname);
2364 else devnameW.Buffer = NULL;
2365
2366 retW = QueryDosDeviceW(devnameW.Buffer, targetW, bufsize);
2367
2368 ret = WideCharToMultiByte(CP_ACP, 0, targetW, retW, target,
2369 bufsize, NULL, NULL);
2370
2371 RtlFreeUnicodeString(&devnameW);
2372 if (targetW) HeapFree(GetProcessHeap(),0,targetW);
2373 return ret;
2374 }
2375
2376
2377 /***********************************************************************
2378 * QueryDosDeviceW (KERNEL32.@)
2379 *
2380 * returns array of strings terminated by \0, terminated by \0
2381 *
2382 * FIXME
2383 * - Win9x returns for all calls ERROR_INVALID_PARAMETER
2384 * - the returned devices for devname == NULL is far from complete
2385 * - its not checked that the returned device exist
2386 */
2387 DWORD WINAPI QueryDosDeviceW(LPCWSTR devname,LPWSTR target,DWORD bufsize)
2388 {
2389 const WCHAR *pDev, *pName, *pNum = NULL;
2390 int numsiz=0;
2391 DWORD ret;
2392
2393 TRACE("(%s,...)\n", debugstr_w(devname));
2394 if (!devname) {
2395 /* return known MSDOS devices */
2396 DWORD ret = 0;
2397 int i;
2398 static const WCHAR devices[][5] = {{'A','U','X',0},
2399 {'C','O','M','1',0},
2400 {'C','O','M','2',0},
2401 {'L','P','T','1',0},
2402 {'N','U','L',0,}};
2403 for(i=0; (i< (sizeof(devices)/sizeof(devices[0]))); i++) {
2404 DWORD len = strlenW(devices[i]);
2405 if(target && (bufsize >= ret + len + 2)) {
2406 strcpyW(target+ret, devices[i]);
2407 ret += len + 1;
2408 } else {
2409 /* in this case WinXP returns 0 */
2410 FIXME("function return is wrong for WinXP!\n");
2411 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2412 break;
2413 }
2414 }
2415 /* append drives here */
2416 if(target && bufsize > 0) target[ret++] = 0;
2417 FIXME("Returned list is not complete\n");
2418 return ret;
2419 }
2420 /* In theory all that are possible and have been defined.
2421 * Now just those below, since mirc uses it to check for special files.
2422 *
2423 * (It is more complex, and supports netmounted stuff, and \\.\ stuff,
2424 * but currently we just ignore that.)
2425 */
2426 if (!strcmpiW(devname, auxW)) {
2427 pDev = dosW;
2428 pName = comW;
2429 numsiz = 1;
2430 pNum = oneW;
2431 } else if (!strcmpiW(devname, nulW)) {
2432 pDev = devW;
2433 pName = nullW;
2434 } else if (!strncmpiW(devname, comW, strlenW(comW))) {
2435 pDev = devW;
2436 pName = serW;
2437 pNum = devname + strlenW(comW);
2438 for(numsiz=0; isdigitW(*(pNum+numsiz)); numsiz++);
2439 if(*(pNum + numsiz)) {
2440 SetLastError(ERROR_FILE_NOT_FOUND);
2441 return 0;
2442 }
2443 } else if (!strncmpiW(devname, lptW, strlenW(lptW))) {
2444 pDev = devW;
2445 pName = parW;
2446 pNum = devname + strlenW(lptW);
2447 for(numsiz=0; isdigitW(*(pNum+numsiz)); numsiz++);
2448 if(*(pNum + numsiz)) {
2449 SetLastError(ERROR_FILE_NOT_FOUND);
2450 return 0;
2451 }
2452 } else {
2453 /* This might be a DOS device we do not handle yet ... */
2454 FIXME("(%s) not detected as DOS device!\n",debugstr_w(devname));
2455
2456 /* Win9x set the error ERROR_INVALID_PARAMETER */
2457 SetLastError(ERROR_FILE_NOT_FOUND);
2458 return 0;
2459 }
2460 FIXME("device %s may not exist on this computer\n", debugstr_w(devname));
2461
2462 ret = strlenW(pDev) + strlenW(pName) + numsiz + 2;
2463 if (ret > bufsize) ret = 0;
2464 if (target && ret) {
2465 strcpyW(target,pDev);
2466 strcatW(target,pName);
2467 if (pNum) strcatW(target,pNum);
2468 target[ret-1] = 0;
2469 }
2470 return ret;
2471 }
2472
2473
2474 /***********************************************************************
2475 * DefineDosDeviceA (KERNEL32.@)
2476 */
2477 BOOL WINAPI DefineDosDeviceA(DWORD flags,LPCSTR devname,LPCSTR targetpath) {
2478 FIXME("(0x%08lx,%s,%s),stub!\n",flags,devname,targetpath);
2479 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2480 return FALSE;
2481 }