2 * DOS file system functions
4 * Copyright 1993 Erik Bos
5 * Copyright 1996 Alexandre Julliard
13 #include <sys/errno.h>
18 #include <sys/ioctl.h>
24 #include "wine/winbase16.h"
34 #include "debugtools.h"
36 DECLARE_DEBUG_CHANNEL(dosfs
)
37 DECLARE_DEBUG_CHANNEL(file
)
39 /* Define the VFAT ioctl to get both short and long file names */
40 /* FIXME: is it possible to get this to work on other systems? */
42 #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, long)
43 /* We want the real kernel dirent structure, not the libc one */
48 unsigned short d_reclen
;
53 #undef VFAT_IOCTL_READDIR_BOTH /* just in case... */
56 /* Chars we don't want to see in DOS file names */
57 #define INVALID_DOS_CHARS "*?<>|\"+=,;[] \345"
59 static const DOS_DEVICE DOSFS_Devices
[] =
60 /* name, device flags (see Int 21/AX=0x4400) */
74 { "SCSIMGR$", 0xc0c0 },
78 #define GET_DRIVE(path) \
79 (((path)[1] == ':') ? toupper((path)[0]) - 'A' : DOSFS_CurDrive)
81 /* Directory info for DOSFS_ReadDir */
85 #ifdef VFAT_IOCTL_READDIR_BOTH
88 KERNEL_DIRENT dirent
[2];
92 /* Info structure for FindFirstFile handle */
106 /***********************************************************************
109 * Return 1 if Unix file 'name' is also a valid MS-DOS name
110 * (i.e. contains only valid DOS chars, lower-case only, fits in 8.3 format).
111 * File name can be terminated by '\0', '\\' or '/'.
113 static int DOSFS_ValidDOSName( const char *name
, int ignore_case
)
115 static const char invalid_chars
[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" INVALID_DOS_CHARS
;
116 const char *p
= name
;
117 const char *invalid
= ignore_case
? (invalid_chars
+ 26) : invalid_chars
;
122 /* Check for "." and ".." */
125 /* All other names beginning with '.' are invalid */
126 return (IS_END_OF_NAME(*p
));
128 while (!IS_END_OF_NAME(*p
))
130 if (strchr( invalid
, *p
)) return 0; /* Invalid char */
131 if (*p
== '.') break; /* Start of the extension */
132 if (++len
> 8) return 0; /* Name too long */
135 if (*p
!= '.') return 1; /* End of name */
137 if (IS_END_OF_NAME(*p
)) return 0; /* Empty extension not allowed */
139 while (!IS_END_OF_NAME(*p
))
141 if (strchr( invalid
, *p
)) return 0; /* Invalid char */
142 if (*p
== '.') return 0; /* Second extension not allowed */
143 if (++len
> 3) return 0; /* Extension too long */
150 /***********************************************************************
151 * DOSFS_ToDosFCBFormat
153 * Convert a file name to DOS FCB format (8+3 chars, padded with blanks),
154 * expanding wild cards and converting to upper-case in the process.
155 * File name can be terminated by '\0', '\\' or '/'.
156 * Return FALSE if the name is not a valid DOS name.
157 * 'buffer' must be at least 12 characters long.
159 BOOL
DOSFS_ToDosFCBFormat( LPCSTR name
, LPSTR buffer
)
161 static const char invalid_chars
[] = INVALID_DOS_CHARS
;
162 const char *p
= name
;
165 /* Check for "." and ".." */
169 strcpy( buffer
, ". " );
175 return (!*p
|| (*p
== '/') || (*p
== '\\'));
178 for (i
= 0; i
< 8; i
++)
195 if (strchr( invalid_chars
, *p
)) return FALSE
;
196 buffer
[i
] = toupper(*p
);
204 /* Skip all chars after wildcard up to first dot */
205 while (*p
&& (*p
!= '/') && (*p
!= '\\') && (*p
!= '.')) p
++;
209 /* Check if name too long */
210 if (*p
&& (*p
!= '/') && (*p
!= '\\') && (*p
!= '.')) return FALSE
;
212 if (*p
== '.') p
++; /* Skip dot */
214 for (i
= 8; i
< 11; i
++)
224 return FALSE
; /* Second extension not allowed */
232 if (strchr( invalid_chars
, *p
)) return FALSE
;
233 buffer
[i
] = toupper(*p
);
243 /***********************************************************************
244 * DOSFS_ToDosDTAFormat
246 * Convert a file name from FCB to DTA format (name.ext, null-terminated)
247 * converting to upper-case in the process.
248 * File name can be terminated by '\0', '\\' or '/'.
249 * 'buffer' must be at least 13 characters long.
251 static void DOSFS_ToDosDTAFormat( LPCSTR name
, LPSTR buffer
)
255 memcpy( buffer
, name
, 8 );
256 for (p
= buffer
+ 8; (p
> buffer
) && (p
[-1] == ' '); p
--);
258 memcpy( p
, name
+ 8, 3 );
259 for (p
+= 3; p
[-1] == ' '; p
--);
260 if (p
[-1] == '.') p
--;
265 /***********************************************************************
268 * Check a DOS file name against a mask (both in FCB format).
270 static int DOSFS_MatchShort( const char *mask
, const char *name
)
273 for (i
= 11; i
> 0; i
--, mask
++, name
++)
274 if ((*mask
!= '?') && (*mask
!= *name
)) return 0;
279 /***********************************************************************
282 * Check a long file name against a mask.
284 static int DOSFS_MatchLong( const char *mask
, const char *name
,
287 if (!strcmp( mask
, "*.*" )) return 1;
288 while (*name
&& *mask
)
293 while (*mask
== '*') mask
++; /* Skip consecutive '*' */
294 if (!*mask
) return 1;
295 if (case_sensitive
) while (*name
&& (*name
!= *mask
)) name
++;
296 else while (*name
&& (toupper(*name
) != toupper(*mask
))) name
++;
299 else if (*mask
!= '?')
303 if (*mask
!= *name
) return 0;
305 else if (toupper(*mask
) != toupper(*name
)) return 0;
310 if (*mask
== '.') mask
++; /* Ignore trailing '.' in mask */
311 return (!*name
&& !*mask
);
315 /***********************************************************************
318 static DOS_DIR
*DOSFS_OpenDir( LPCSTR path
)
320 DOS_DIR
*dir
= HeapAlloc( SystemHeap
, 0, sizeof(*dir
) );
323 SetLastError( ERROR_NOT_ENOUGH_MEMORY
);
327 /* Treat empty path as root directory. This simplifies path split into
328 directory and mask in several other places */
329 if (!*path
) path
= "/";
331 #ifdef VFAT_IOCTL_READDIR_BOTH
333 /* Check if the VFAT ioctl is supported on this directory */
335 if ((dir
->fd
= open( path
, O_RDONLY
)) != -1)
337 if (ioctl( dir
->fd
, VFAT_IOCTL_READDIR_BOTH
, (long)dir
->dirent
) == -1)
344 /* Set the file pointer back at the start of the directory */
345 lseek( dir
->fd
, 0, SEEK_SET
);
350 #endif /* VFAT_IOCTL_READDIR_BOTH */
352 /* Now use the standard opendir/readdir interface */
354 if (!(dir
->dir
= opendir( path
)))
356 HeapFree( SystemHeap
, 0, dir
);
363 /***********************************************************************
366 static void DOSFS_CloseDir( DOS_DIR
*dir
)
368 #ifdef VFAT_IOCTL_READDIR_BOTH
369 if (dir
->fd
!= -1) close( dir
->fd
);
370 #endif /* VFAT_IOCTL_READDIR_BOTH */
371 if (dir
->dir
) closedir( dir
->dir
);
372 HeapFree( SystemHeap
, 0, dir
);
376 /***********************************************************************
379 static BOOL
DOSFS_ReadDir( DOS_DIR
*dir
, LPCSTR
*long_name
,
382 struct dirent
*dirent
;
384 #ifdef VFAT_IOCTL_READDIR_BOTH
387 if (ioctl( dir
->fd
, VFAT_IOCTL_READDIR_BOTH
, (long)dir
->dirent
) != -1) {
388 if (!dir
->dirent
[0].d_reclen
) return FALSE
;
389 if (!DOSFS_ToDosFCBFormat( dir
->dirent
[0].d_name
, dir
->short_name
))
390 dir
->short_name
[0] = '\0';
391 *short_name
= dir
->short_name
;
392 if (dir
->dirent
[1].d_name
[0]) *long_name
= dir
->dirent
[1].d_name
;
393 else *long_name
= dir
->dirent
[0].d_name
;
397 #endif /* VFAT_IOCTL_READDIR_BOTH */
399 if (!(dirent
= readdir( dir
->dir
))) return FALSE
;
400 *long_name
= dirent
->d_name
;
406 /***********************************************************************
409 * Transform a Unix file name into a hashed DOS name. If the name is a valid
410 * DOS name, it is converted to upper-case; otherwise it is replaced by a
411 * hashed version that fits in 8.3 format.
412 * File name can be terminated by '\0', '\\' or '/'.
413 * 'buffer' must be at least 13 characters long.
415 static void DOSFS_Hash( LPCSTR name
, LPSTR buffer
, BOOL dir_format
,
418 static const char invalid_chars
[] = INVALID_DOS_CHARS
"~.";
419 static const char hash_chars
[32] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ012345";
426 if (dir_format
) strcpy( buffer
, " " );
428 if (DOSFS_ValidDOSName( name
, ignore_case
))
430 /* Check for '.' and '..' */
434 if (!dir_format
) buffer
[1] = buffer
[2] = '\0';
435 if (name
[1] == '.') buffer
[1] = '.';
439 /* Simply copy the name, converting to uppercase */
441 for (dst
= buffer
; !IS_END_OF_NAME(*name
) && (*name
!= '.'); name
++)
442 *dst
++ = toupper(*name
);
445 if (dir_format
) dst
= buffer
+ 8;
447 for (name
++; !IS_END_OF_NAME(*name
); name
++)
448 *dst
++ = toupper(*name
);
450 if (!dir_format
) *dst
= '\0';
454 /* Compute the hash code of the file name */
455 /* If you know something about hash functions, feel free to */
456 /* insert a better algorithm here... */
459 for (p
= name
, hash
= 0xbeef; !IS_END_OF_NAME(p
[1]); p
++)
460 hash
= (hash
<<3) ^ (hash
>>5) ^ tolower(*p
) ^ (tolower(p
[1]) << 8);
461 hash
= (hash
<<3) ^ (hash
>>5) ^ tolower(*p
); /* Last character*/
465 for (p
= name
, hash
= 0xbeef; !IS_END_OF_NAME(p
[1]); p
++)
466 hash
= (hash
<< 3) ^ (hash
>> 5) ^ *p
^ (p
[1] << 8);
467 hash
= (hash
<< 3) ^ (hash
>> 5) ^ *p
; /* Last character */
470 /* Find last dot for start of the extension */
471 for (p
= name
+1, ext
= NULL
; !IS_END_OF_NAME(*p
); p
++)
472 if (*p
== '.') ext
= p
;
473 if (ext
&& IS_END_OF_NAME(ext
[1]))
474 ext
= NULL
; /* Empty extension ignored */
476 /* Copy first 4 chars, replacing invalid chars with '_' */
477 for (i
= 4, p
= name
, dst
= buffer
; i
> 0; i
--, p
++)
479 if (IS_END_OF_NAME(*p
) || (p
== ext
)) break;
480 *dst
++ = strchr( invalid_chars
, *p
) ? '_' : toupper(*p
);
482 /* Pad to 5 chars with '~' */
483 while (i
-- >= 0) *dst
++ = '~';
485 /* Insert hash code converted to 3 ASCII chars */
486 *dst
++ = hash_chars
[(hash
>> 10) & 0x1f];
487 *dst
++ = hash_chars
[(hash
>> 5) & 0x1f];
488 *dst
++ = hash_chars
[hash
& 0x1f];
490 /* Copy the first 3 chars of the extension (if any) */
493 if (!dir_format
) *dst
++ = '.';
494 for (i
= 3, ext
++; (i
> 0) && !IS_END_OF_NAME(*ext
); i
--, ext
++)
495 *dst
++ = strchr( invalid_chars
, *ext
) ? '_' : toupper(*ext
);
497 if (!dir_format
) *dst
= '\0';
501 /***********************************************************************
504 * Find the Unix file name in a given directory that corresponds to
505 * a file name (either in Unix or DOS format).
506 * File name can be terminated by '\0', '\\' or '/'.
507 * Return TRUE if OK, FALSE if no file name matches.
509 * 'long_buf' must be at least 'long_len' characters long. If the long name
510 * turns out to be larger than that, the function returns FALSE.
511 * 'short_buf' must be at least 13 characters long.
513 BOOL
DOSFS_FindUnixName( LPCSTR path
, LPCSTR name
, LPSTR long_buf
,
514 INT long_len
, LPSTR short_buf
, BOOL ignore_case
)
517 LPCSTR long_name
, short_name
;
518 char dos_name
[12], tmp_buf
[13];
521 const char *p
= strchr( name
, '/' );
522 int len
= p
? (int)(p
- name
) : strlen(name
);
523 if ((p
= strchr( name
, '\\' ))) len
= MIN( (int)(p
- name
), len
);
524 /* Ignore trailing dots */
525 while (len
> 1 && name
[len
-1] == '.') len
--;
526 if (long_len
< len
+ 1) return FALSE
;
528 TRACE_(dosfs
)("%s,%s\n", path
, name
);
530 if (!DOSFS_ToDosFCBFormat( name
, dos_name
)) dos_name
[0] = '\0';
532 if (!(dir
= DOSFS_OpenDir( path
)))
534 WARN_(dosfs
)("(%s,%s): can't open dir: %s\n",
535 path
, name
, strerror(errno
) );
539 while ((ret
= DOSFS_ReadDir( dir
, &long_name
, &short_name
)))
541 /* Check against Unix name */
542 if (len
== strlen(long_name
))
546 if (!lstrncmpA( long_name
, name
, len
)) break;
550 if (!lstrncmpiA( long_name
, name
, len
)) break;
555 /* Check against hashed DOS name */
558 DOSFS_Hash( long_name
, tmp_buf
, TRUE
, ignore_case
);
559 short_name
= tmp_buf
;
561 if (!strcmp( dos_name
, short_name
)) break;
566 if (long_buf
) strcpy( long_buf
, long_name
);
570 DOSFS_ToDosDTAFormat( short_name
, short_buf
);
572 DOSFS_Hash( long_name
, short_buf
, FALSE
, ignore_case
);
574 TRACE_(dosfs
)("(%s,%s) -> %s (%s)\n",
575 path
, name
, long_name
, short_buf
? short_buf
: "***");
578 WARN_(dosfs
)("'%s' not found in '%s'\n", name
, path
);
579 DOSFS_CloseDir( dir
);
584 /***********************************************************************
587 * Check if a DOS file name represents a DOS device and return the device.
589 const DOS_DEVICE
*DOSFS_GetDevice( const char *name
)
594 if (!name
) return NULL
; /* if FILE_DupUnixHandle was used */
595 if (name
[0] && (name
[1] == ':')) name
+= 2;
596 if ((p
= strrchr( name
, '/' ))) name
= p
+ 1;
597 if ((p
= strrchr( name
, '\\' ))) name
= p
+ 1;
598 for (i
= 0; i
< sizeof(DOSFS_Devices
)/sizeof(DOSFS_Devices
[0]); i
++)
600 const char *dev
= DOSFS_Devices
[i
].name
;
601 if (!lstrncmpiA( dev
, name
, strlen(dev
) ))
603 p
= name
+ strlen( dev
);
604 if (!*p
|| (*p
== '.')) return &DOSFS_Devices
[i
];
611 /***********************************************************************
612 * DOSFS_GetDeviceByHandle
614 const DOS_DEVICE
*DOSFS_GetDeviceByHandle( HFILE hFile
)
616 struct get_file_info_request req
;
617 struct get_file_info_reply reply
;
620 CLIENT_SendRequest( REQ_GET_FILE_INFO
, -1, 1, &req
, sizeof(req
) );
621 if (!CLIENT_WaitSimpleReply( &reply
, sizeof(reply
), NULL
) &&
622 (reply
.type
== FILE_TYPE_UNKNOWN
))
624 if ((reply
.attr
>= 0) &&
625 (reply
.attr
< sizeof(DOSFS_Devices
)/sizeof(DOSFS_Devices
[0])))
626 return &DOSFS_Devices
[reply
.attr
];
632 /***********************************************************************
635 * Open a DOS device. This might not map 1:1 into the UNIX device concept.
637 HFILE
DOSFS_OpenDevice( const char *name
, DWORD access
)
642 if (!name
) return (HFILE
)NULL
; /* if FILE_DupUnixHandle was used */
643 if (name
[0] && (name
[1] == ':')) name
+= 2;
644 if ((p
= strrchr( name
, '/' ))) name
= p
+ 1;
645 if ((p
= strrchr( name
, '\\' ))) name
= p
+ 1;
646 for (i
= 0; i
< sizeof(DOSFS_Devices
)/sizeof(DOSFS_Devices
[0]); i
++)
648 const char *dev
= DOSFS_Devices
[i
].name
;
649 if (!lstrncmpiA( dev
, name
, strlen(dev
) ))
651 p
= name
+ strlen( dev
);
652 if (!*p
|| (*p
== '.')) {
654 if (!strcmp(DOSFS_Devices
[i
].name
,"NUL"))
655 return FILE_CreateFile( "/dev/null", access
,
656 FILE_SHARE_READ
|FILE_SHARE_WRITE
, NULL
,
657 OPEN_EXISTING
, 0, -1 );
658 if (!strcmp(DOSFS_Devices
[i
].name
,"CON")) {
661 switch (access
& (GENERIC_READ
|GENERIC_WRITE
)) {
663 to_dup
= GetStdHandle( STD_INPUT_HANDLE
);
666 to_dup
= GetStdHandle( STD_OUTPUT_HANDLE
);
669 FIXME_(dosfs
)("can't open CON read/write\n");
673 if (!DuplicateHandle( GetCurrentProcess(), to_dup
, GetCurrentProcess(),
674 &handle
, 0, FALSE
, DUPLICATE_SAME_ACCESS
))
675 handle
= HFILE_ERROR
;
678 if (!strcmp(DOSFS_Devices
[i
].name
,"SCSIMGR$") ||
679 !strcmp(DOSFS_Devices
[i
].name
,"HPSCAN"))
681 return FILE_CreateDevice( i
, access
, NULL
);
686 PROFILE_GetWineIniString("serialports",name
,"",devname
,sizeof devname
);
690 TRACE_(file
)("DOSFS_OpenDevice %s is %s\n",
691 DOSFS_Devices
[i
].name
,devname
);
692 r
= FILE_CreateFile( devname
, access
,
693 FILE_SHARE_READ
|FILE_SHARE_WRITE
, NULL
,
694 OPEN_EXISTING
, 0, -1 );
695 TRACE_(file
)("Create_File return %08X\n",r
);
700 FIXME_(dosfs
)("device open %s not supported (yet)\n",DOSFS_Devices
[i
].name
);
709 /***********************************************************************
712 * Get the drive specified by a given path name (DOS or Unix format).
714 static int DOSFS_GetPathDrive( const char **name
)
717 const char *p
= *name
;
719 if (*p
&& (p
[1] == ':'))
721 drive
= toupper(*p
) - 'A';
724 else if (*p
== '/') /* Absolute Unix path? */
726 if ((drive
= DRIVE_FindDriveRoot( name
)) == -1)
728 MESSAGE("Warning: %s not accessible from a DOS drive\n", *name
);
729 /* Assume it really was a DOS name */
730 drive
= DRIVE_GetCurrentDrive();
733 else drive
= DRIVE_GetCurrentDrive();
735 if (!DRIVE_IsValid(drive
))
737 SetLastError( ERROR_INVALID_DRIVE
);
744 /***********************************************************************
747 * Convert a file name (DOS or mixed DOS/Unix format) to a valid
748 * Unix name / short DOS name pair.
749 * Return FALSE if one of the path components does not exist. The last path
750 * component is only checked if 'check_last' is non-zero.
751 * The buffers pointed to by 'long_buf' and 'short_buf' must be
752 * at least MAX_PATHNAME_LEN long.
754 BOOL
DOSFS_GetFullName( LPCSTR name
, BOOL check_last
, DOS_FULL_NAME
*full
)
758 char *p_l
, *p_s
, *root
;
760 TRACE_(dosfs
)("%s (last=%d)\n",
763 if ((full
->drive
= DOSFS_GetPathDrive( &name
)) == -1) return FALSE
;
764 flags
= DRIVE_GetFlags( full
->drive
);
766 lstrcpynA( full
->long_name
, DRIVE_GetRoot( full
->drive
),
767 sizeof(full
->long_name
) );
768 if (full
->long_name
[1]) root
= full
->long_name
+ strlen(full
->long_name
);
769 else root
= full
->long_name
; /* root directory */
771 strcpy( full
->short_name
, "A:\\" );
772 full
->short_name
[0] += full
->drive
;
774 if ((*name
== '\\') || (*name
== '/')) /* Absolute path */
776 while ((*name
== '\\') || (*name
== '/')) name
++;
778 else /* Relative path */
780 lstrcpynA( root
+ 1, DRIVE_GetUnixCwd( full
->drive
),
781 sizeof(full
->long_name
) - (root
- full
->long_name
) - 1 );
782 if (root
[1]) *root
= '/';
783 lstrcpynA( full
->short_name
+ 3, DRIVE_GetDosCwd( full
->drive
),
784 sizeof(full
->short_name
) - 3 );
787 p_l
= full
->long_name
[1] ? full
->long_name
+ strlen(full
->long_name
)
789 p_s
= full
->short_name
[3] ? full
->short_name
+ strlen(full
->short_name
)
790 : full
->short_name
+ 2;
793 while (*name
&& found
)
795 /* Check for '.' and '..' */
799 if (IS_END_OF_NAME(name
[1]))
802 while ((*name
== '\\') || (*name
== '/')) name
++;
805 else if ((name
[1] == '.') && IS_END_OF_NAME(name
[2]))
808 while ((*name
== '\\') || (*name
== '/')) name
++;
809 while ((p_l
> root
) && (*p_l
!= '/')) p_l
--;
810 while ((p_s
> full
->short_name
+ 2) && (*p_s
!= '\\')) p_s
--;
811 *p_l
= *p_s
= '\0'; /* Remove trailing separator */
816 /* Make sure buffers are large enough */
818 if ((p_s
>= full
->short_name
+ sizeof(full
->short_name
) - 14) ||
819 (p_l
>= full
->long_name
+ sizeof(full
->long_name
) - 1))
821 SetLastError( ERROR_PATH_NOT_FOUND
);
825 /* Get the long and short name matching the file name */
827 if ((found
= DOSFS_FindUnixName( full
->long_name
, name
, p_l
+ 1,
828 sizeof(full
->long_name
) - (p_l
- full
->long_name
) - 1,
829 p_s
+ 1, !(flags
& DRIVE_CASE_SENSITIVE
) )))
835 while (!IS_END_OF_NAME(*name
)) name
++;
837 else if (!check_last
)
841 while (!IS_END_OF_NAME(*name
) &&
842 (p_s
< full
->short_name
+ sizeof(full
->short_name
) - 1) &&
843 (p_l
< full
->long_name
+ sizeof(full
->long_name
) - 1))
845 *p_s
++ = tolower(*name
);
846 /* If the drive is case-sensitive we want to create new */
847 /* files in lower-case otherwise we can't reopen them */
848 /* under the same short name. */
849 if (flags
& DRIVE_CASE_SENSITIVE
) *p_l
++ = tolower(*name
);
855 while ((*name
== '\\') || (*name
== '/')) name
++;
862 SetLastError( ERROR_FILE_NOT_FOUND
);
865 if (*name
) /* Not last */
867 SetLastError( ERROR_PATH_NOT_FOUND
);
871 if (!full
->long_name
[0]) strcpy( full
->long_name
, "/" );
872 if (!full
->short_name
[2]) strcpy( full
->short_name
+ 2, "\\" );
873 TRACE_(dosfs
)("returning %s = %s\n",
874 full
->long_name
, full
->short_name
);
879 /***********************************************************************
880 * GetShortPathNameA (KERNEL32.271)
884 * longpath=NULL: LastError=ERROR_INVALID_PARAMETER, ret=0
885 * *longpath="" or invalid: LastError=ERROR_BAD_PATHNAME, ret=0
887 * more observations ( with NT 3.51 (WinDD) ):
888 * longpath <= 8.3 -> just copy longpath to shortpath
890 * a) file does not exist -> return 0, LastError = ERROR_FILE_NOT_FOUND
891 * b) file does exist -> set the short filename.
892 * - trailing slashes are reproduced in the short name, even if the
893 * file is not a directory
894 * - the absolute/relative path of the short name is reproduced in the
895 * same way, like the long name
896 * - longpath and shortpath may have the same adress
899 DWORD WINAPI
GetShortPathNameA( LPCSTR longpath
, LPSTR shortpath
,
902 DOS_FULL_NAME full_name
;
904 DWORD length
= 0, pos
= 0;
905 INT start
=-1, end
=-1, tmplen
;
908 SetLastError(ERROR_INVALID_PARAMETER
);
912 SetLastError(ERROR_BAD_PATHNAME
);
916 tmpshortpath
= HeapAlloc( GetProcessHeap(), 0, MAX_PATHNAME_LEN
);
917 if ( !tmpshortpath
) {
918 SetLastError ( ERROR_NOT_ENOUGH_MEMORY
);
922 /* Check for Drive-Letter */
923 if ( longpath
[1] == ':' ) {
924 lstrcpynA ( tmpshortpath
, longpath
, 3 );
929 /* loop over each part of the name */
930 while ( longpath
[pos
] ) {
932 if (( longpath
[pos
] == '\\' ) ||
933 ( longpath
[pos
+1] == '\0' ) ||
934 ( longpath
[pos
] == '/')) {
937 if ( DOSFS_ValidDOSName ( longpath
+ start
, TRUE
)) {
938 tmplen
= end
- start
+ ( (( longpath
[pos
] == '\\' ) || ( longpath
[pos
] == '/' )) ? 1 : 2 );
939 lstrcpynA ( tmpshortpath
+length
, longpath
+start
, tmplen
);
940 length
+= tmplen
- 1;
943 DOSFS_Hash ( longpath
+ start
, tmpshortpath
+length
, FALSE
, FALSE
);
944 length
= lstrlenA ( tmpshortpath
);
946 /* Check if the path, up to this point exists */
947 if ( !DOSFS_GetFullName ( tmpshortpath
, TRUE
, &full_name
) ) {
948 SetLastError ( ERROR_FILE_NOT_FOUND
);
955 if (( longpath
[pos
] == '\\' ) || ( longpath
[pos
] == '/' )) {
956 tmpshortpath
[length
] = '\\';
957 tmpshortpath
[length
+1]='\0';
974 lstrcpynA ( shortpath
, tmpshortpath
, shortlen
);
975 length
= lstrlenA ( tmpshortpath
);
976 HeapFree ( GetProcessHeap(), 0, tmpshortpath
);
982 /***********************************************************************
983 * GetShortPathName32W (KERNEL32.272)
985 DWORD WINAPI
GetShortPathNameW( LPCWSTR longpath
, LPWSTR shortpath
,
988 LPSTR longpathA
, shortpathA
;
991 longpathA
= HEAP_strdupWtoA( GetProcessHeap(), 0, longpath
);
992 shortpathA
= HEAP_xalloc ( GetProcessHeap(), 0, shortlen
);
994 ret
= GetShortPathNameA ( longpathA
, shortpathA
, shortlen
);
995 lstrcpynAtoW ( shortpath
, shortpathA
, shortlen
);
997 HeapFree( GetProcessHeap(), 0, longpathA
);
998 HeapFree( GetProcessHeap(), 0, shortpathA
);
1004 /***********************************************************************
1005 * GetLongPathName32A (KERNEL32.xxx)
1007 DWORD WINAPI
GetLongPathNameA( LPCSTR shortpath
, LPSTR longpath
,
1010 DOS_FULL_NAME full_name
;
1015 if (!DOSFS_GetFullName( shortpath
, TRUE
, &full_name
)) return 0;
1016 lstrcpynA( longpath
, full_name
.short_name
, longlen
);
1017 /* Do some hackery to get the long filename.
1018 * FIXME: Would be better if it returned the
1019 * long version of the directories too
1021 longfilename
= strrchr(full_name
.long_name
, '/')+1;
1022 if (longpath
!= NULL
) {
1023 if ((p
= strrchr( longpath
, '\\' )) != NULL
) {
1025 longlen
-= (p
-longpath
);
1026 lstrcpynA( p
, longfilename
, longlen
);
1030 ((strrchr( full_name
.short_name
, '\\' ) - full_name
.short_name
) + 1);
1031 return shortpathlen
+ strlen( longfilename
);
1035 /***********************************************************************
1036 * GetLongPathName32W (KERNEL32.269)
1038 DWORD WINAPI
GetLongPathNameW( LPCWSTR shortpath
, LPWSTR longpath
,
1041 DOS_FULL_NAME full_name
;
1043 LPSTR shortpathA
= HEAP_strdupWtoA( GetProcessHeap(), 0, shortpath
);
1045 /* FIXME: is it correct to always return a fully qualified short path? */
1046 if (DOSFS_GetFullName( shortpathA
, TRUE
, &full_name
))
1048 ret
= strlen( full_name
.short_name
);
1049 lstrcpynAtoW( longpath
, full_name
.long_name
, longlen
);
1051 HeapFree( GetProcessHeap(), 0, shortpathA
);
1056 /***********************************************************************
1057 * DOSFS_DoGetFullPathName
1059 * Implementation of GetFullPathName32A/W.
1061 static DWORD
DOSFS_DoGetFullPathName( LPCSTR name
, DWORD len
, LPSTR result
,
1064 char buffer
[MAX_PATHNAME_LEN
];
1069 /* last possible position for a char != 0 */
1070 char *endchar
= buffer
+ sizeof(buffer
) - 2;
1073 TRACE_(dosfs
)("converting '%s'\n", name
);
1075 if (!name
|| ((drive
= DOSFS_GetPathDrive( &name
)) == -1) )
1076 { SetLastError( ERROR_INVALID_PARAMETER
);
1083 if (IS_END_OF_NAME(*name
) && (*name
)) /* Absolute path */
1085 while (((*name
== '\\') || (*name
== '/')) && (!*endchar
) )
1088 else /* Relative path or empty path */
1091 lstrcpynA( p
, DRIVE_GetDosCwd(drive
), sizeof(buffer
) - 4 );
1104 if (IS_END_OF_NAME(name
[1]))
1107 while ((*name
== '\\') || (*name
== '/')) name
++;
1110 else if ((name
[1] == '.') && IS_END_OF_NAME(name
[2]))
1113 while ((*name
== '\\') || (*name
== '/')) name
++;
1115 if (p
< buffer
+ 3) /* no previous dir component */
1117 p
--; /* skip previously added '\\' */
1118 while ((*p
== '\\') || (*p
== '/')) p
--;
1119 /* skip previous dir component */
1120 while ((*p
!= '\\') && (*p
!= '/')) p
--;
1126 { SetLastError( ERROR_PATH_NOT_FOUND
);
1129 while (!IS_END_OF_NAME(*name
) && (!*endchar
) )
1131 while (((*name
== '\\') || (*name
== '/')) && (!*endchar
) )
1136 if (!(DRIVE_GetFlags(drive
) & DRIVE_CASE_PRESERVING
))
1137 CharUpperA( buffer
);
1142 lstrcpynAtoW( (LPWSTR
)result
, buffer
, len
);
1144 lstrcpynA( result
, buffer
, len
);
1147 TRACE_(dosfs
)("returning '%s'\n", buffer
);
1149 /* If the lpBuffer buffer is too small, the return value is the
1150 size of the buffer, in characters, required to hold the path. */
1152 ret
= strlen(buffer
);
1155 SetLastError( ERROR_INSUFFICIENT_BUFFER
);
1161 /***********************************************************************
1162 * GetFullPathName32A (KERNEL32.272)
1164 * if the path closed with '\', *lastpart is 0
1166 DWORD WINAPI
GetFullPathNameA( LPCSTR name
, DWORD len
, LPSTR buffer
,
1169 DWORD ret
= DOSFS_DoGetFullPathName( name
, len
, buffer
, FALSE
);
1170 if (ret
&& buffer
&& lastpart
)
1172 LPSTR p
= buffer
+ strlen(buffer
);
1176 while ((p
> buffer
+ 2) && (*p
!= '\\')) p
--;
1179 else *lastpart
= NULL
;
1185 /***********************************************************************
1186 * GetFullPathName32W (KERNEL32.273)
1188 DWORD WINAPI
GetFullPathNameW( LPCWSTR name
, DWORD len
, LPWSTR buffer
,
1191 LPSTR nameA
= HEAP_strdupWtoA( GetProcessHeap(), 0, name
);
1192 DWORD ret
= DOSFS_DoGetFullPathName( nameA
, len
, (LPSTR
)buffer
, TRUE
);
1193 HeapFree( GetProcessHeap(), 0, nameA
);
1194 if (ret
&& buffer
&& lastpart
)
1196 LPWSTR p
= buffer
+ lstrlenW(buffer
);
1197 if (*p
!= (WCHAR
)'\\')
1199 while ((p
> buffer
+ 2) && (*p
!= (WCHAR
)'\\')) p
--;
1202 else *lastpart
= NULL
;
1207 /***********************************************************************
1210 static int DOSFS_FindNextEx( FIND_FIRST_INFO
*info
, WIN32_FIND_DATAA
*entry
)
1212 BYTE attr
= info
->attr
| FA_UNUSED
| FA_ARCHIVE
| FA_RDONLY
;
1213 UINT flags
= DRIVE_GetFlags( info
->drive
);
1214 char *p
, buffer
[MAX_PATHNAME_LEN
];
1215 const char *drive_path
;
1217 LPCSTR long_name
, short_name
;
1218 BY_HANDLE_FILE_INFORMATION fileinfo
;
1221 if ((info
->attr
& ~(FA_UNUSED
| FA_ARCHIVE
| FA_RDONLY
)) == FA_LABEL
)
1223 if (info
->cur_pos
) return 0;
1224 entry
->dwFileAttributes
= FILE_ATTRIBUTE_LABEL
;
1225 DOSFS_UnixTimeToFileTime( (time_t)0, &entry
->ftCreationTime
, 0 );
1226 DOSFS_UnixTimeToFileTime( (time_t)0, &entry
->ftLastAccessTime
, 0 );
1227 DOSFS_UnixTimeToFileTime( (time_t)0, &entry
->ftLastWriteTime
, 0 );
1228 entry
->nFileSizeHigh
= 0;
1229 entry
->nFileSizeLow
= 0;
1230 entry
->dwReserved0
= 0;
1231 entry
->dwReserved1
= 0;
1232 DOSFS_ToDosDTAFormat( DRIVE_GetLabel( info
->drive
), entry
->cFileName
);
1233 strcpy( entry
->cAlternateFileName
, entry
->cFileName
);
1238 drive_path
= info
->path
+ strlen(DRIVE_GetRoot( info
->drive
));
1239 while ((*drive_path
== '/') || (*drive_path
== '\\')) drive_path
++;
1240 drive_root
= !*drive_path
;
1242 lstrcpynA( buffer
, info
->path
, sizeof(buffer
) - 1 );
1243 strcat( buffer
, "/" );
1244 p
= buffer
+ strlen(buffer
);
1246 while (DOSFS_ReadDir( info
->dir
, &long_name
, &short_name
))
1250 /* Don't return '.' and '..' in the root of the drive */
1251 if (drive_root
&& (long_name
[0] == '.') &&
1252 (!long_name
[1] || ((long_name
[1] == '.') && !long_name
[2])))
1255 /* Check the long mask */
1257 if (info
->long_mask
)
1259 if (!DOSFS_MatchLong( info
->long_mask
, long_name
,
1260 flags
& DRIVE_CASE_SENSITIVE
)) continue;
1263 /* Check the short mask */
1265 if (info
->short_mask
)
1269 DOSFS_Hash( long_name
, dos_name
, TRUE
,
1270 !(flags
& DRIVE_CASE_SENSITIVE
) );
1271 short_name
= dos_name
;
1273 if (!DOSFS_MatchShort( info
->short_mask
, short_name
)) continue;
1276 /* Check the file attributes */
1278 lstrcpynA( p
, long_name
, sizeof(buffer
) - (int)(p
- buffer
) );
1279 if (!FILE_Stat( buffer
, &fileinfo
))
1281 WARN_(dosfs
)("can't stat %s\n", buffer
);
1284 if (fileinfo
.dwFileAttributes
& ~attr
) continue;
1286 /* We now have a matching entry; fill the result and return */
1288 entry
->dwFileAttributes
= fileinfo
.dwFileAttributes
;
1289 entry
->ftCreationTime
= fileinfo
.ftCreationTime
;
1290 entry
->ftLastAccessTime
= fileinfo
.ftLastAccessTime
;
1291 entry
->ftLastWriteTime
= fileinfo
.ftLastWriteTime
;
1292 entry
->nFileSizeHigh
= fileinfo
.nFileSizeHigh
;
1293 entry
->nFileSizeLow
= fileinfo
.nFileSizeLow
;
1296 DOSFS_ToDosDTAFormat( short_name
, entry
->cAlternateFileName
);
1298 DOSFS_Hash( long_name
, entry
->cAlternateFileName
, FALSE
,
1299 !(flags
& DRIVE_CASE_SENSITIVE
) );
1301 lstrcpynA( entry
->cFileName
, long_name
, sizeof(entry
->cFileName
) );
1302 if (!(flags
& DRIVE_CASE_PRESERVING
)) CharLowerA( entry
->cFileName
);
1303 TRACE_(dosfs
)("returning %s (%s) %02lx %ld\n",
1304 entry
->cFileName
, entry
->cAlternateFileName
,
1305 entry
->dwFileAttributes
, entry
->nFileSizeLow
);
1308 return 0; /* End of directory */
1311 /***********************************************************************
1314 * Find the next matching file. Return the number of entries read to find
1315 * the matching one, or 0 if no more entries.
1316 * 'short_mask' is the 8.3 mask (in FCB format), 'long_mask' is the long
1317 * file name mask. Either or both can be NULL.
1319 * NOTE: This is supposed to be only called by the int21 emulation
1320 * routines. Thus, we should own the Win16Mutex anyway.
1321 * Nevertheless, we explicitly enter it to ensure the static
1322 * directory cache is protected.
1324 int DOSFS_FindNext( const char *path
, const char *short_mask
,
1325 const char *long_mask
, int drive
, BYTE attr
,
1326 int skip
, WIN32_FIND_DATAA
*entry
)
1328 static FIND_FIRST_INFO info
= { NULL
};
1329 LPCSTR short_name
, long_name
;
1332 SYSLEVEL_EnterWin16Lock();
1334 /* Check the cached directory */
1335 if (!(info
.dir
&& info
.path
== path
&& info
.short_mask
== short_mask
1336 && info
.long_mask
== long_mask
&& info
.drive
== drive
1337 && info
.attr
== attr
&& info
.cur_pos
<= skip
))
1339 /* Not in the cache, open it anew */
1340 if (info
.dir
) DOSFS_CloseDir( info
.dir
);
1342 info
.path
= (LPSTR
)path
;
1343 info
.long_mask
= (LPSTR
)long_mask
;
1344 info
.short_mask
= (LPSTR
)short_mask
;
1348 info
.dir
= DOSFS_OpenDir( info
.path
);
1351 /* Skip to desired position */
1352 while (info
.cur_pos
< skip
)
1353 if (info
.dir
&& DOSFS_ReadDir( info
.dir
, &long_name
, &short_name
))
1358 if (info
.dir
&& info
.cur_pos
== skip
&& DOSFS_FindNextEx( &info
, entry
))
1359 count
= info
.cur_pos
- skip
;
1365 if (info
.dir
) DOSFS_CloseDir( info
.dir
);
1366 memset( &info
, '\0', sizeof(info
) );
1369 SYSLEVEL_LeaveWin16Lock();
1376 /*************************************************************************
1377 * FindFirstFile16 (KERNEL.413)
1379 HANDLE16 WINAPI
FindFirstFile16( LPCSTR path
, WIN32_FIND_DATAA
*data
)
1381 DOS_FULL_NAME full_name
;
1383 FIND_FIRST_INFO
*info
;
1385 data
->dwReserved0
= data
->dwReserved1
= 0x0;
1386 if (!path
) return 0;
1387 if (!DOSFS_GetFullName( path
, FALSE
, &full_name
))
1388 return INVALID_HANDLE_VALUE16
;
1389 if (!(handle
= GlobalAlloc16( GMEM_MOVEABLE
, sizeof(FIND_FIRST_INFO
) )))
1390 return INVALID_HANDLE_VALUE16
;
1391 info
= (FIND_FIRST_INFO
*)GlobalLock16( handle
);
1392 info
->path
= HEAP_strdupA( SystemHeap
, 0, full_name
.long_name
);
1393 info
->long_mask
= strrchr( info
->path
, '/' );
1394 *(info
->long_mask
++) = '\0';
1395 info
->short_mask
= NULL
;
1397 if (path
[0] && (path
[1] == ':')) info
->drive
= toupper(*path
) - 'A';
1398 else info
->drive
= DRIVE_GetCurrentDrive();
1401 info
->dir
= DOSFS_OpenDir( info
->path
);
1403 GlobalUnlock16( handle
);
1404 if (!FindNextFile16( handle
, data
))
1406 FindClose16( handle
);
1407 SetLastError( ERROR_NO_MORE_FILES
);
1408 return INVALID_HANDLE_VALUE16
;
1414 /*************************************************************************
1415 * FindFirstFile32A (KERNEL32.123)
1417 HANDLE WINAPI
FindFirstFileA( LPCSTR path
, WIN32_FIND_DATAA
*data
)
1419 HANDLE handle
= FindFirstFile16( path
, data
);
1420 if (handle
== INVALID_HANDLE_VALUE16
) return INVALID_HANDLE_VALUE
;
1425 /*************************************************************************
1426 * FindFirstFile32W (KERNEL32.124)
1428 HANDLE WINAPI
FindFirstFileW( LPCWSTR path
, WIN32_FIND_DATAW
*data
)
1430 WIN32_FIND_DATAA dataA
;
1431 LPSTR pathA
= HEAP_strdupWtoA( GetProcessHeap(), 0, path
);
1432 HANDLE handle
= FindFirstFileA( pathA
, &dataA
);
1433 HeapFree( GetProcessHeap(), 0, pathA
);
1434 if (handle
!= INVALID_HANDLE_VALUE
)
1436 data
->dwFileAttributes
= dataA
.dwFileAttributes
;
1437 data
->ftCreationTime
= dataA
.ftCreationTime
;
1438 data
->ftLastAccessTime
= dataA
.ftLastAccessTime
;
1439 data
->ftLastWriteTime
= dataA
.ftLastWriteTime
;
1440 data
->nFileSizeHigh
= dataA
.nFileSizeHigh
;
1441 data
->nFileSizeLow
= dataA
.nFileSizeLow
;
1442 lstrcpyAtoW( data
->cFileName
, dataA
.cFileName
);
1443 lstrcpyAtoW( data
->cAlternateFileName
, dataA
.cAlternateFileName
);
1449 /*************************************************************************
1450 * FindNextFile16 (KERNEL.414)
1452 BOOL16 WINAPI
FindNextFile16( HANDLE16 handle
, WIN32_FIND_DATAA
*data
)
1454 FIND_FIRST_INFO
*info
;
1456 if (!(info
= (FIND_FIRST_INFO
*)GlobalLock16( handle
)))
1458 SetLastError( ERROR_INVALID_HANDLE
);
1461 GlobalUnlock16( handle
);
1462 if (!info
->path
|| !info
->dir
)
1464 SetLastError( ERROR_NO_MORE_FILES
);
1467 if (!DOSFS_FindNextEx( info
, data
))
1469 DOSFS_CloseDir( info
->dir
); info
->dir
= NULL
;
1470 HeapFree( SystemHeap
, 0, info
->path
);
1471 info
->path
= info
->long_mask
= NULL
;
1472 SetLastError( ERROR_NO_MORE_FILES
);
1479 /*************************************************************************
1480 * FindNextFile32A (KERNEL32.126)
1482 BOOL WINAPI
FindNextFileA( HANDLE handle
, WIN32_FIND_DATAA
*data
)
1484 return FindNextFile16( handle
, data
);
1488 /*************************************************************************
1489 * FindNextFile32W (KERNEL32.127)
1491 BOOL WINAPI
FindNextFileW( HANDLE handle
, WIN32_FIND_DATAW
*data
)
1493 WIN32_FIND_DATAA dataA
;
1494 if (!FindNextFileA( handle
, &dataA
)) return FALSE
;
1495 data
->dwFileAttributes
= dataA
.dwFileAttributes
;
1496 data
->ftCreationTime
= dataA
.ftCreationTime
;
1497 data
->ftLastAccessTime
= dataA
.ftLastAccessTime
;
1498 data
->ftLastWriteTime
= dataA
.ftLastWriteTime
;
1499 data
->nFileSizeHigh
= dataA
.nFileSizeHigh
;
1500 data
->nFileSizeLow
= dataA
.nFileSizeLow
;
1501 lstrcpyAtoW( data
->cFileName
, dataA
.cFileName
);
1502 lstrcpyAtoW( data
->cAlternateFileName
, dataA
.cAlternateFileName
);
1507 /*************************************************************************
1508 * FindClose16 (KERNEL.415)
1510 BOOL16 WINAPI
FindClose16( HANDLE16 handle
)
1512 FIND_FIRST_INFO
*info
;
1514 if ((handle
== INVALID_HANDLE_VALUE16
) ||
1515 !(info
= (FIND_FIRST_INFO
*)GlobalLock16( handle
)))
1517 SetLastError( ERROR_INVALID_HANDLE
);
1520 if (info
->dir
) DOSFS_CloseDir( info
->dir
);
1521 if (info
->path
) HeapFree( SystemHeap
, 0, info
->path
);
1522 GlobalUnlock16( handle
);
1523 GlobalFree16( handle
);
1528 /*************************************************************************
1529 * FindClose32 (KERNEL32.119)
1531 BOOL WINAPI
FindClose( HANDLE handle
)
1533 return FindClose16( (HANDLE16
)handle
);
1537 /***********************************************************************
1538 * DOSFS_UnixTimeToFileTime
1540 * Convert a Unix time to FILETIME format.
1541 * The FILETIME structure is a 64-bit value representing the number of
1542 * 100-nanosecond intervals since January 1, 1601, 0:00.
1543 * 'remainder' is the nonnegative number of 100-ns intervals
1544 * corresponding to the time fraction smaller than 1 second that
1545 * couldn't be stored in the time_t value.
1547 void DOSFS_UnixTimeToFileTime( time_t unix_time
, FILETIME
*filetime
,
1553 The time difference between 1 January 1601, 00:00:00 and
1554 1 January 1970, 00:00:00 is 369 years, plus the leap years
1555 from 1604 to 1968, excluding 1700, 1800, 1900.
1556 This makes (1968 - 1600) / 4 - 3 = 89 leap days, and a total
1559 Any day in that period had 24 * 60 * 60 = 86400 seconds.
1561 The time difference is 134774 * 86400 * 10000000, which can be written
1563 27111902 * 2^32 + 3577643008
1564 413 * 2^48 + 45534 * 2^32 + 54590 * 2^16 + 32768
1566 If you find that these constants are buggy, please change them in all
1567 instances in both conversion functions.
1570 There are two versions, one of them uses long long variables and
1571 is presumably faster but not ISO C. The other one uses standard C
1572 data types and operations but relies on the assumption that negative
1573 numbers are stored as 2's complement (-1 is 0xffff....). If this
1574 assumption is violated, dates before 1970 will not convert correctly.
1575 This should however work on any reasonable architecture where WINE
1580 Take care not to remove the casts. I have tested these functions
1581 (in both versions) for a lot of numbers. I would be interested in
1582 results on other compilers than GCC.
1584 The operations have been designed to account for the possibility
1585 of 64-bit time_t in future UNICES. Even the versions without
1586 internal long long numbers will work if time_t only is 64 bit.
1587 A 32-bit shift, which was necessary for that operation, turned out
1588 not to work correctly in GCC, besides giving the warning. So I
1589 used a double 16-bit shift instead. Numbers are in the ISO version
1590 represented by three limbs, the most significant with 32 bit, the
1591 other two with 16 bit each.
1593 As the modulo-operator % is not well-defined for negative numbers,
1594 negative divisors have been avoided in DOSFS_FileTimeToUnixTime.
1596 There might be quicker ways to do this in C. Certainly so in
1599 Claus Fischer, fischer@iue.tuwien.ac.at
1602 #if (SIZEOF_LONG_LONG >= 8)
1603 # define USE_LONG_LONG 1
1605 # define USE_LONG_LONG 0
1608 #if USE_LONG_LONG /* gcc supports long long type */
1610 long long int t
= unix_time
;
1612 t
+= 116444736000000000LL;
1614 filetime
->dwLowDateTime
= (UINT
)t
;
1615 filetime
->dwHighDateTime
= (UINT
)(t
>> 32);
1617 #else /* ISO version */
1619 UINT a0
; /* 16 bit, low bits */
1620 UINT a1
; /* 16 bit, medium bits */
1621 UINT a2
; /* 32 bit, high bits */
1623 /* Copy the unix time to a2/a1/a0 */
1624 a0
= unix_time
& 0xffff;
1625 a1
= (unix_time
>> 16) & 0xffff;
1626 /* This is obsolete if unix_time is only 32 bits, but it does not hurt.
1627 Do not replace this by >> 32, it gives a compiler warning and it does
1629 a2
= (unix_time
>= 0 ? (unix_time
>> 16) >> 16 :
1630 ~((~unix_time
>> 16) >> 16));
1632 /* Multiply a by 10000000 (a = a2/a1/a0)
1633 Split the factor into 10000 * 1000 which are both less than 0xffff. */
1635 a1
= a1
* 10000 + (a0
>> 16);
1636 a2
= a2
* 10000 + (a1
>> 16);
1641 a1
= a1
* 1000 + (a0
>> 16);
1642 a2
= a2
* 1000 + (a1
>> 16);
1646 /* Add the time difference and the remainder */
1647 a0
+= 32768 + (remainder
& 0xffff);
1648 a1
+= 54590 + (remainder
>> 16 ) + (a0
>> 16);
1649 a2
+= 27111902 + (a1
>> 16);
1654 filetime
->dwLowDateTime
= (a1
<< 16) + a0
;
1655 filetime
->dwHighDateTime
= a2
;
1660 /***********************************************************************
1661 * DOSFS_FileTimeToUnixTime
1663 * Convert a FILETIME format to Unix time.
1664 * If not NULL, 'remainder' contains the fractional part of the filetime,
1665 * in the range of [0..9999999] (even if time_t is negative).
1667 time_t DOSFS_FileTimeToUnixTime( const FILETIME
*filetime
, DWORD
*remainder
)
1669 /* Read the comment in the function DOSFS_UnixTimeToFileTime. */
1672 long long int t
= filetime
->dwHighDateTime
;
1674 t
+= (UINT
)filetime
->dwLowDateTime
;
1675 t
-= 116444736000000000LL;
1678 if (remainder
) *remainder
= 9999999 - (-t
- 1) % 10000000;
1679 return -1 - ((-t
- 1) / 10000000);
1683 if (remainder
) *remainder
= t
% 10000000;
1684 return t
/ 10000000;
1687 #else /* ISO version */
1689 UINT a0
; /* 16 bit, low bits */
1690 UINT a1
; /* 16 bit, medium bits */
1691 UINT a2
; /* 32 bit, high bits */
1692 UINT r
; /* remainder of division */
1693 unsigned int carry
; /* carry bit for subtraction */
1694 int negative
; /* whether a represents a negative value */
1696 /* Copy the time values to a2/a1/a0 */
1697 a2
= (UINT
)filetime
->dwHighDateTime
;
1698 a1
= ((UINT
)filetime
->dwLowDateTime
) >> 16;
1699 a0
= ((UINT
)filetime
->dwLowDateTime
) & 0xffff;
1701 /* Subtract the time difference */
1702 if (a0
>= 32768 ) a0
-= 32768 , carry
= 0;
1703 else a0
+= (1 << 16) - 32768 , carry
= 1;
1705 if (a1
>= 54590 + carry
) a1
-= 54590 + carry
, carry
= 0;
1706 else a1
+= (1 << 16) - 54590 - carry
, carry
= 1;
1708 a2
-= 27111902 + carry
;
1710 /* If a is negative, replace a by (-1-a) */
1711 negative
= (a2
>= ((UINT
)1) << 31);
1714 /* Set a to -a - 1 (a is a2/a1/a0) */
1720 /* Divide a by 10000000 (a = a2/a1/a0), put the rest into r.
1721 Split the divisor into 10000 * 1000 which are both less than 0xffff. */
1722 a1
+= (a2
% 10000) << 16;
1724 a0
+= (a1
% 10000) << 16;
1729 a1
+= (a2
% 1000) << 16;
1731 a0
+= (a1
% 1000) << 16;
1733 r
+= (a0
% 1000) * 10000;
1736 /* If a was negative, replace a by (-1-a) and r by (9999999 - r) */
1739 /* Set a to -a - 1 (a is a2/a1/a0) */
1747 if (remainder
) *remainder
= r
;
1749 /* Do not replace this by << 32, it gives a compiler warning and it does
1751 return ((((time_t)a2
) << 16) << 16) + (a1
<< 16) + a0
;
1756 /***********************************************************************
1757 * DosDateTimeToFileTime (KERNEL32.76)
1759 BOOL WINAPI
DosDateTimeToFileTime( WORD fatdate
, WORD fattime
, LPFILETIME ft
)
1763 newtm
.tm_sec
= (fattime
& 0x1f) * 2;
1764 newtm
.tm_min
= (fattime
>> 5) & 0x3f;
1765 newtm
.tm_hour
= (fattime
>> 11);
1766 newtm
.tm_mday
= (fatdate
& 0x1f);
1767 newtm
.tm_mon
= ((fatdate
>> 5) & 0x0f) - 1;
1768 newtm
.tm_year
= (fatdate
>> 9) + 80;
1769 DOSFS_UnixTimeToFileTime( mktime( &newtm
), ft
, 0 );
1774 /***********************************************************************
1775 * FileTimeToDosDateTime (KERNEL32.111)
1777 BOOL WINAPI
FileTimeToDosDateTime( const FILETIME
*ft
, LPWORD fatdate
,
1780 time_t unixtime
= DOSFS_FileTimeToUnixTime( ft
, NULL
);
1781 struct tm
*tm
= localtime( &unixtime
);
1783 *fattime
= (tm
->tm_hour
<< 11) + (tm
->tm_min
<< 5) + (tm
->tm_sec
/ 2);
1785 *fatdate
= ((tm
->tm_year
- 80) << 9) + ((tm
->tm_mon
+ 1) << 5)
1791 /***********************************************************************
1792 * LocalFileTimeToFileTime (KERNEL32.373)
1794 BOOL WINAPI
LocalFileTimeToFileTime( const FILETIME
*localft
,
1800 /* convert from local to UTC. Perhaps not correct. FIXME */
1801 time_t unixtime
= DOSFS_FileTimeToUnixTime( localft
, &remainder
);
1802 xtm
= gmtime( &unixtime
);
1803 DOSFS_UnixTimeToFileTime( mktime(xtm
), utcft
, remainder
);
1808 /***********************************************************************
1809 * FileTimeToLocalFileTime (KERNEL32.112)
1811 BOOL WINAPI
FileTimeToLocalFileTime( const FILETIME
*utcft
,
1812 LPFILETIME localft
)
1815 /* convert from UTC to local. Perhaps not correct. FIXME */
1816 time_t unixtime
= DOSFS_FileTimeToUnixTime( utcft
, &remainder
);
1818 struct tm
*xtm
= localtime( &unixtime
);
1821 localtime
= timegm(xtm
);
1822 DOSFS_UnixTimeToFileTime( localtime
, localft
, remainder
);
1825 struct tm
*xtm
,*gtm
;
1828 xtm
= localtime( &unixtime
);
1829 gtm
= gmtime( &unixtime
);
1830 time1
= mktime(xtm
);
1831 time2
= mktime(gtm
);
1832 DOSFS_UnixTimeToFileTime( 2*time1
-time2
, localft
, remainder
);
1838 /***********************************************************************
1839 * FileTimeToSystemTime (KERNEL32.113)
1841 BOOL WINAPI
FileTimeToSystemTime( const FILETIME
*ft
, LPSYSTEMTIME syst
)
1845 time_t xtime
= DOSFS_FileTimeToUnixTime( ft
, &remainder
);
1846 xtm
= gmtime(&xtime
);
1847 syst
->wYear
= xtm
->tm_year
+1900;
1848 syst
->wMonth
= xtm
->tm_mon
+ 1;
1849 syst
->wDayOfWeek
= xtm
->tm_wday
;
1850 syst
->wDay
= xtm
->tm_mday
;
1851 syst
->wHour
= xtm
->tm_hour
;
1852 syst
->wMinute
= xtm
->tm_min
;
1853 syst
->wSecond
= xtm
->tm_sec
;
1854 syst
->wMilliseconds
= remainder
/ 10000;
1858 /***********************************************************************
1859 * QueryDosDeviceA (KERNEL32.413)
1861 * returns array of strings terminated by \0, terminated by \0
1863 DWORD WINAPI
QueryDosDeviceA(LPCSTR devname
,LPSTR target
,DWORD bufsize
)
1868 TRACE_(dosfs
)("(%s,...)\n",devname
?devname
:"<null>");
1870 /* return known MSDOS devices */
1871 lstrcpyA(buffer
,"CON COM1 COM2 LPT1 NUL ");
1872 while ((s
=strchr(buffer
,' ')))
1875 lstrcpynA(target
,buffer
,bufsize
);
1876 return strlen(buffer
);
1878 lstrcpyA(buffer
,"\\DEV\\");
1879 lstrcatA(buffer
,devname
);
1880 if ((s
=strchr(buffer
,':'))) *s
='\0';
1881 lstrcpynA(target
,buffer
,bufsize
);
1882 return strlen(buffer
);
1886 /***********************************************************************
1887 * QueryDosDeviceW (KERNEL32.414)
1889 * returns array of strings terminated by \0, terminated by \0
1891 DWORD WINAPI
QueryDosDeviceW(LPCWSTR devname
,LPWSTR target
,DWORD bufsize
)
1893 LPSTR devnameA
= devname
?HEAP_strdupWtoA(GetProcessHeap(),0,devname
):NULL
;
1894 LPSTR targetA
= (LPSTR
)HEAP_xalloc(GetProcessHeap(),0,bufsize
);
1895 DWORD ret
= QueryDosDeviceA(devnameA
,targetA
,bufsize
);
1897 lstrcpynAtoW(target
,targetA
,bufsize
);
1898 if (devnameA
) HeapFree(GetProcessHeap(),0,devnameA
);
1899 if (targetA
) HeapFree(GetProcessHeap(),0,targetA
);
1904 /***********************************************************************
1905 * SystemTimeToFileTime (KERNEL32.526)
1907 BOOL WINAPI
SystemTimeToFileTime( const SYSTEMTIME
*syst
, LPFILETIME ft
)
1913 struct tm xtm
,*local_tm
,*utc_tm
;
1914 time_t localtim
,utctime
;
1917 xtm
.tm_year
= syst
->wYear
-1900;
1918 xtm
.tm_mon
= syst
->wMonth
- 1;
1919 xtm
.tm_wday
= syst
->wDayOfWeek
;
1920 xtm
.tm_mday
= syst
->wDay
;
1921 xtm
.tm_hour
= syst
->wHour
;
1922 xtm
.tm_min
= syst
->wMinute
;
1923 xtm
.tm_sec
= syst
->wSecond
; /* this is UTC */
1926 utctime
= timegm(&xtm
);
1927 DOSFS_UnixTimeToFileTime( utctime
, ft
,
1928 syst
->wMilliseconds
* 10000 );
1930 localtim
= mktime(&xtm
); /* now we've got local time */
1931 local_tm
= localtime(&localtim
);
1932 utc_tm
= gmtime(&localtim
);
1933 utctime
= mktime(utc_tm
);
1934 DOSFS_UnixTimeToFileTime( 2*localtim
-utctime
, ft
,
1935 syst
->wMilliseconds
* 10000 );
1940 BOOL WINAPI
DefineDosDeviceA(DWORD flags
,LPCSTR devname
,LPCSTR targetpath
) {
1941 FIXME_(dosfs
)("(0x%08lx,%s,%s),stub!\n",flags
,devname
,targetpath
);
1942 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);