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