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