2 * DOS drives handling functions
4 * Copyright 1993 Erik Bos
5 * Copyright 1996 Alexandre Julliard
14 #include <sys/types.h>
19 #ifdef HAVE_SYS_PARAM_H
20 # include <sys/param.h>
22 #ifdef STATFS_DEFINED_BY_SYS_VFS
25 # ifdef STATFS_DEFINED_BY_SYS_MOUNT
26 # include <sys/mount.h>
28 # ifdef STATFS_DEFINED_BY_SYS_STATFS
29 # include <sys/statfs.h>
46 char *root
; /* root dir in Unix format without trailing / */
47 char *dos_cwd
; /* cwd in DOS format without leading or trailing \ */
48 char *unix_cwd
; /* cwd in Unix format without leading or trailing / */
49 char *device
; /* raw device path */
50 char label
[12]; /* drive label */
51 DWORD serial
; /* drive serial number */
52 DRIVETYPE type
; /* drive type */
53 UINT32 flags
; /* drive flags */
54 dev_t dev
; /* unix device number */
55 ino_t ino
; /* unix inode number */
59 static const char * const DRIVE_Types
[] =
61 "floppy", /* TYPE_FLOPPY */
63 "cdrom", /* TYPE_CDROM */
64 "network" /* TYPE_NETWORK */
68 /* Known filesystem types */
76 static const FS_DESCR DRIVE_Filesystems
[] =
78 { "unix", DRIVE_CASE_SENSITIVE
| DRIVE_CASE_PRESERVING
},
79 { "msdos", DRIVE_SHORT_NAMES
},
80 { "dos", DRIVE_SHORT_NAMES
},
81 { "fat", DRIVE_SHORT_NAMES
},
82 { "vfat", DRIVE_CASE_PRESERVING
},
83 { "win95", DRIVE_CASE_PRESERVING
},
88 static DOSDRIVE DOSDrives
[MAX_DOS_DRIVES
];
89 static int DRIVE_CurDrive
= -1;
91 static HTASK16 DRIVE_LastTask
= 0;
94 /***********************************************************************
97 static DRIVETYPE
DRIVE_GetDriveType( const char *name
)
102 PROFILE_GetWineIniString( name
, "Type", "hd", buffer
, sizeof(buffer
) );
103 for (i
= 0; i
< sizeof(DRIVE_Types
)/sizeof(DRIVE_Types
[0]); i
++)
105 if (!lstrcmpi32A( buffer
, DRIVE_Types
[i
] )) return (DRIVETYPE
)i
;
107 MSG("%s: unknown type '%s', defaulting to 'hd'.\n", name
, buffer
);
112 /***********************************************************************
115 static UINT32
DRIVE_GetFSFlags( const char *name
, const char *value
)
117 const FS_DESCR
*descr
;
119 for (descr
= DRIVE_Filesystems
; descr
->name
; descr
++)
120 if (!lstrcmpi32A( value
, descr
->name
)) return descr
->flags
;
121 MSG("%s: unknown filesystem type '%s', defaulting to 'unix'.\n",
123 return DRIVE_CASE_SENSITIVE
| DRIVE_CASE_PRESERVING
;
127 /***********************************************************************
132 int i
, len
, count
= 0;
133 char name
[] = "Drive A";
134 char path
[MAX_PATHNAME_LEN
];
136 struct stat drive_stat_buffer
;
140 for (i
= 0, drive
= DOSDrives
; i
< MAX_DOS_DRIVES
; i
++, name
[6]++, drive
++)
142 PROFILE_GetWineIniString( name
, "Path", "", path
, sizeof(path
)-1 );
145 p
= path
+ strlen(path
) - 1;
146 while ((p
> path
) && ((*p
== '/') || (*p
== '\\'))) *p
-- = '\0';
147 if (!path
[0]) strcpy( path
, "/" );
149 if (stat( path
, &drive_stat_buffer
))
151 MSG("Could not stat %s, ignoring drive %c:\n", path
, 'A' + i
);
154 if (!S_ISDIR(drive_stat_buffer
.st_mode
))
156 MSG("%s is not a directory, ignoring drive %c:\n",
161 drive
->root
= HEAP_strdupA( SystemHeap
, 0, path
);
162 drive
->dos_cwd
= HEAP_strdupA( SystemHeap
, 0, "" );
163 drive
->unix_cwd
= HEAP_strdupA( SystemHeap
, 0, "" );
164 drive
->type
= DRIVE_GetDriveType( name
);
165 drive
->device
= NULL
;
167 drive
->dev
= drive_stat_buffer
.st_dev
;
168 drive
->ino
= drive_stat_buffer
.st_ino
;
170 /* Get the drive label */
171 PROFILE_GetWineIniString( name
, "Label", name
, drive
->label
, 12 );
172 if ((len
= strlen(drive
->label
)) < 11)
174 /* Pad label with spaces */
175 memset( drive
->label
+ len
, ' ', 11 - len
);
176 drive
->label
[12] = '\0';
179 /* Get the serial number */
180 PROFILE_GetWineIniString( name
, "Serial", "12345678",
181 buffer
, sizeof(buffer
) );
182 drive
->serial
= strtoul( buffer
, NULL
, 16 );
184 /* Get the filesystem type */
185 PROFILE_GetWineIniString( name
, "Filesystem", "unix",
186 buffer
, sizeof(buffer
) );
187 drive
->flags
= DRIVE_GetFSFlags( name
, buffer
);
190 PROFILE_GetWineIniString( name
, "Device", "",
191 buffer
, sizeof(buffer
) );
193 drive
->device
= HEAP_strdupA( SystemHeap
, 0, buffer
);
195 /* Make the first hard disk the current drive */
196 if ((DRIVE_CurDrive
== -1) && (drive
->type
== TYPE_HD
))
200 TRACE(dosfs
, "%s: path=%s type=%s label='%s' serial=%08lx flags=%08x dev=%x ino=%x\n",
201 name
, path
, DRIVE_Types
[drive
->type
],
202 drive
->label
, drive
->serial
, drive
->flags
,
203 (int)drive
->dev
, (int)drive
->ino
);
205 else WARN(dosfs
, "%s: not defined\n", name
);
210 MSG("Warning: no valid DOS drive found, check your configuration file.\n" );
211 /* Create a C drive pointing to Unix root dir */
212 DOSDrives
[2].root
= HEAP_strdupA( SystemHeap
, 0, "/" );
213 DOSDrives
[2].dos_cwd
= HEAP_strdupA( SystemHeap
, 0, "" );
214 DOSDrives
[2].unix_cwd
= HEAP_strdupA( SystemHeap
, 0, "" );
215 strcpy( DOSDrives
[2].label
, "Drive C " );
216 DOSDrives
[2].serial
= 0x12345678;
217 DOSDrives
[2].type
= TYPE_HD
;
218 DOSDrives
[2].flags
= 0;
222 /* Make sure the current drive is valid */
223 if (DRIVE_CurDrive
== -1)
225 for (i
= 0, drive
= DOSDrives
; i
< MAX_DOS_DRIVES
; i
++, drive
++)
227 if (drive
->root
&& !(drive
->flags
& DRIVE_DISABLED
))
239 /***********************************************************************
242 int DRIVE_IsValid( int drive
)
244 if ((drive
< 0) || (drive
>= MAX_DOS_DRIVES
)) return 0;
245 return (DOSDrives
[drive
].root
&&
246 !(DOSDrives
[drive
].flags
& DRIVE_DISABLED
));
250 /***********************************************************************
251 * DRIVE_GetCurrentDrive
253 int DRIVE_GetCurrentDrive(void)
255 TDB
*pTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
256 if (pTask
&& (pTask
->curdrive
& 0x80)) return pTask
->curdrive
& ~0x80;
257 return DRIVE_CurDrive
;
261 /***********************************************************************
262 * DRIVE_SetCurrentDrive
264 int DRIVE_SetCurrentDrive( int drive
)
266 TDB
*pTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
267 if (!DRIVE_IsValid( drive
))
269 DOS_ERROR( ER_InvalidDrive
, EC_MediaError
, SA_Abort
, EL_Disk
);
272 TRACE(dosfs
, "%c:\n", 'A' + drive
);
273 DRIVE_CurDrive
= drive
;
274 if (pTask
) pTask
->curdrive
= drive
| 0x80;
279 /***********************************************************************
280 * DRIVE_FindDriveRoot
282 * Find a drive for which the root matches the begginning of the given path.
283 * This can be used to translate a Unix path into a drive + DOS path.
284 * Return value is the drive, or -1 on error. On success, path is modified
285 * to point to the beginning of the DOS path.
287 int DRIVE_FindDriveRoot( const char **path
)
289 /* idea: check at all '/' positions.
290 * If the device and inode of that path is identical with the
291 * device and inode of the current drive then we found a solution.
292 * If there is another drive pointing to a deeper position in
293 * the file tree, we want to find that one, not the earlier solution.
295 int drive
, rootdrive
= -1;
296 char buffer
[MAX_PATHNAME_LEN
];
298 const char *p
= *path
;
301 strcpy( buffer
, "/" );
304 if (stat( buffer
, &st
) || !S_ISDIR( st
.st_mode
)) break;
308 for (drive
= 0; drive
< MAX_DOS_DRIVES
; drive
++)
310 if (!DOSDrives
[drive
].root
||
311 (DOSDrives
[drive
].flags
& DRIVE_DISABLED
)) continue;
313 if ((DOSDrives
[drive
].dev
== st
.st_dev
) &&
314 (DOSDrives
[drive
].ino
== st
.st_ino
))
321 /* Get the next path component */
324 while ((*p
== '/') || (*p
== '\\')) p
++;
326 while (!IS_END_OF_NAME(*p
)) *next
++ = *p
++;
332 TRACE(dosfs
, "%s -> drive %c:, root='%s', name='%s'\n",
333 buffer
, 'A' + rootdrive
,
334 DOSDrives
[rootdrive
].root
, *path
);
339 /***********************************************************************
342 const char * DRIVE_GetRoot( int drive
)
344 if (!DRIVE_IsValid( drive
)) return NULL
;
345 return DOSDrives
[drive
].root
;
349 /***********************************************************************
352 const char * DRIVE_GetDosCwd( int drive
)
354 TDB
*pTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
355 if (!DRIVE_IsValid( drive
)) return NULL
;
357 /* Check if we need to change the directory to the new task. */
358 if (pTask
&& (pTask
->curdrive
& 0x80) && /* The task drive is valid */
359 ((pTask
->curdrive
& ~0x80) == drive
) && /* and it's the one we want */
360 (DRIVE_LastTask
!= GetCurrentTask())) /* and the task changed */
362 /* Perform the task-switch */
363 if (!DRIVE_Chdir( drive
, pTask
->curdir
)) DRIVE_Chdir( drive
, "\\" );
364 DRIVE_LastTask
= GetCurrentTask();
366 return DOSDrives
[drive
].dos_cwd
;
370 /***********************************************************************
373 const char * DRIVE_GetUnixCwd( int drive
)
375 TDB
*pTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
376 if (!DRIVE_IsValid( drive
)) return NULL
;
378 /* Check if we need to change the directory to the new task. */
379 if (pTask
&& (pTask
->curdrive
& 0x80) && /* The task drive is valid */
380 ((pTask
->curdrive
& ~0x80) == drive
) && /* and it's the one we want */
381 (DRIVE_LastTask
!= GetCurrentTask())) /* and the task changed */
383 /* Perform the task-switch */
384 if (!DRIVE_Chdir( drive
, pTask
->curdir
)) DRIVE_Chdir( drive
, "\\" );
385 DRIVE_LastTask
= GetCurrentTask();
387 return DOSDrives
[drive
].unix_cwd
;
391 /***********************************************************************
394 const char * DRIVE_GetLabel( int drive
)
396 if (!DRIVE_IsValid( drive
)) return NULL
;
397 return DOSDrives
[drive
].label
;
401 /***********************************************************************
402 * DRIVE_GetSerialNumber
404 DWORD
DRIVE_GetSerialNumber( int drive
)
406 if (!DRIVE_IsValid( drive
)) return 0;
407 return DOSDrives
[drive
].serial
;
411 /***********************************************************************
412 * DRIVE_SetSerialNumber
414 int DRIVE_SetSerialNumber( int drive
, DWORD serial
)
416 if (!DRIVE_IsValid( drive
)) return 0;
417 DOSDrives
[drive
].serial
= serial
;
422 /***********************************************************************
425 DRIVETYPE
DRIVE_GetType( int drive
)
427 if (!DRIVE_IsValid( drive
)) return TYPE_INVALID
;
428 return DOSDrives
[drive
].type
;
432 /***********************************************************************
435 UINT32
DRIVE_GetFlags( int drive
)
437 if ((drive
< 0) || (drive
>= MAX_DOS_DRIVES
)) return 0;
438 return DOSDrives
[drive
].flags
;
442 /***********************************************************************
445 int DRIVE_Chdir( int drive
, const char *path
)
447 DOS_FULL_NAME full_name
;
448 char buffer
[MAX_PATHNAME_LEN
];
450 BY_HANDLE_FILE_INFORMATION info
;
451 TDB
*pTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
453 TRACE(dosfs
, "(%c:,%s)\n", 'A' + drive
, path
);
454 strcpy( buffer
, "A:" );
456 lstrcpyn32A( buffer
+ 2, path
, sizeof(buffer
) - 2 );
458 if (!DOSFS_GetFullName( buffer
, TRUE
, &full_name
)) return 0;
459 if (!FILE_Stat( full_name
.long_name
, &info
)) return 0;
460 if (!(info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
))
462 DOS_ERROR( ER_FileNotFound
, EC_NotFound
, SA_Abort
, EL_Disk
);
465 unix_cwd
= full_name
.long_name
+ strlen( DOSDrives
[drive
].root
);
466 while (*unix_cwd
== '/') unix_cwd
++;
468 TRACE(dosfs
, "(%c:): unix_cwd=%s dos_cwd=%s\n",
469 'A' + drive
, unix_cwd
, full_name
.short_name
+ 3 );
471 HeapFree( SystemHeap
, 0, DOSDrives
[drive
].dos_cwd
);
472 HeapFree( SystemHeap
, 0, DOSDrives
[drive
].unix_cwd
);
473 DOSDrives
[drive
].dos_cwd
= HEAP_strdupA( SystemHeap
, 0,
474 full_name
.short_name
+ 3 );
475 DOSDrives
[drive
].unix_cwd
= HEAP_strdupA( SystemHeap
, 0, unix_cwd
);
477 if (pTask
&& (pTask
->curdrive
& 0x80) &&
478 ((pTask
->curdrive
& ~0x80) == drive
))
480 lstrcpyn32A( pTask
->curdir
, full_name
.short_name
+ 2,
481 sizeof(pTask
->curdir
) );
482 DRIVE_LastTask
= GetCurrentTask();
488 /***********************************************************************
491 int DRIVE_Disable( int drive
)
493 if ((drive
< 0) || (drive
>= MAX_DOS_DRIVES
) || !DOSDrives
[drive
].root
)
495 DOS_ERROR( ER_InvalidDrive
, EC_MediaError
, SA_Abort
, EL_Disk
);
498 DOSDrives
[drive
].flags
|= DRIVE_DISABLED
;
503 /***********************************************************************
506 int DRIVE_Enable( int drive
)
508 if ((drive
< 0) || (drive
>= MAX_DOS_DRIVES
) || !DOSDrives
[drive
].root
)
510 DOS_ERROR( ER_InvalidDrive
, EC_MediaError
, SA_Abort
, EL_Disk
);
513 DOSDrives
[drive
].flags
&= ~DRIVE_DISABLED
;
518 /***********************************************************************
519 * DRIVE_SetLogicalMapping
521 int DRIVE_SetLogicalMapping ( int existing_drive
, int new_drive
)
523 /* If new_drive is already valid, do nothing and return 0
524 otherwise, copy DOSDrives[existing_drive] to DOSDrives[new_drive] */
528 old
= DOSDrives
+ existing_drive
;
529 new = DOSDrives
+ new_drive
;
531 if ((existing_drive
< 0) || (existing_drive
>= MAX_DOS_DRIVES
) ||
533 (new_drive
< 0) || (new_drive
>= MAX_DOS_DRIVES
))
535 DOS_ERROR( ER_InvalidDrive
, EC_MediaError
, SA_Abort
, EL_Disk
);
541 TRACE(dosfs
, "Can\'t map drive %c to drive %c - "
542 "drive %c already exists\n",
543 'A' + existing_drive
, 'A' + new_drive
,
548 new->root
= HEAP_strdupA( SystemHeap
, 0, old
->root
);
549 new->dos_cwd
= HEAP_strdupA( SystemHeap
, 0, old
->dos_cwd
);
550 new->unix_cwd
= HEAP_strdupA( SystemHeap
, 0, old
->unix_cwd
);
551 memcpy ( new->label
, old
->label
, 12 );
552 new->serial
= old
->serial
;
553 new->type
= old
->type
;
554 new->flags
= old
->flags
;
558 TRACE(dosfs
, "Drive %c is now equal to drive %c\n",
559 'A' + new_drive
, 'A' + existing_drive
);
565 /***********************************************************************
568 * Open the drive raw device and return a Unix fd (or -1 on error).
570 int DRIVE_OpenDevice( int drive
, int flags
)
572 if (!DRIVE_IsValid( drive
)) return -1;
573 return open( DOSDrives
[drive
].device
, flags
);
577 /***********************************************************************
580 static int DRIVE_GetFreeSpace( int drive
, DWORD
*size
, DWORD
*available
)
584 if (!DRIVE_IsValid(drive
))
586 DOS_ERROR( ER_InvalidDrive
, EC_MediaError
, SA_Abort
, EL_Disk
);
590 /* FIXME: add autoconf check for this */
591 #if defined(__svr4__) || defined(_SCO_DS)
592 if (statfs( DOSDrives
[drive
].root
, &info
, 0, 0) < 0)
594 if (statfs( DOSDrives
[drive
].root
, &info
) < 0)
598 WARN(dosfs
, "cannot do statfs(%s)\n", DOSDrives
[drive
].root
);
602 *size
= info
.f_bsize
* info
.f_blocks
;
603 #ifdef STATFS_HAS_BAVAIL
604 *available
= info
.f_bavail
* info
.f_bsize
;
606 # ifdef STATFS_HAS_BFREE
607 *available
= info
.f_bfree
* info
.f_bsize
;
609 # error "statfs has no bfree/bavail member!"
616 /***********************************************************************
617 * GetDiskFreeSpace16 (KERNEL.422)
619 BOOL16 WINAPI
GetDiskFreeSpace16( LPCSTR root
, LPDWORD cluster_sectors
,
620 LPDWORD sector_bytes
, LPDWORD free_clusters
,
621 LPDWORD total_clusters
)
623 return GetDiskFreeSpace32A( root
, cluster_sectors
, sector_bytes
,
624 free_clusters
, total_clusters
);
628 /***********************************************************************
629 * GetDiskFreeSpace32A (KERNEL32.206)
631 BOOL32 WINAPI
GetDiskFreeSpace32A( LPCSTR root
, LPDWORD cluster_sectors
,
632 LPDWORD sector_bytes
, LPDWORD free_clusters
,
633 LPDWORD total_clusters
)
636 DWORD size
,available
;
638 if (!root
) drive
= DRIVE_GetCurrentDrive();
641 if ((root
[1]) && ((root
[1] != ':') || (root
[2] != '\\')))
643 WARN(dosfs
, "invalid root '%s'\n", root
);
646 drive
= toupper(root
[0]) - 'A';
648 if (!DRIVE_GetFreeSpace(drive
, &size
, &available
)) return FALSE
;
650 /* Cap the size and available at 2GB as per specs. */
651 if (size
> 0x7fffffff) size
= 0x7fffffff;
652 if (available
> 0x7fffffff) available
= 0x7fffffff;
654 if (DRIVE_GetType(drive
)==TYPE_CDROM
) {
655 *sector_bytes
= 2048;
663 /* fixme: probably have to adjust those variables too for CDFS */
664 *cluster_sectors
= 1;
665 while (*cluster_sectors
* 65536 < size
) *cluster_sectors
*= 2;
666 *free_clusters
= available
/ *cluster_sectors
;
667 *total_clusters
= size
/ *cluster_sectors
;
672 /***********************************************************************
673 * GetDiskFreeSpace32W (KERNEL32.207)
675 BOOL32 WINAPI
GetDiskFreeSpace32W( LPCWSTR root
, LPDWORD cluster_sectors
,
676 LPDWORD sector_bytes
, LPDWORD free_clusters
,
677 LPDWORD total_clusters
)
682 xroot
= HEAP_strdupWtoA( GetProcessHeap(), 0, root
);
683 ret
= GetDiskFreeSpace32A( xroot
,cluster_sectors
, sector_bytes
,
684 free_clusters
, total_clusters
);
685 HeapFree( GetProcessHeap(), 0, xroot
);
690 /***********************************************************************
691 * GetDiskFreeSpaceEx32A (KERNEL32.871)
693 BOOL32 WINAPI
GetDiskFreeSpaceEx32A( LPCSTR root
,
694 LPULARGE_INTEGER avail
,
695 LPULARGE_INTEGER total
,
696 LPULARGE_INTEGER totalfree
)
699 DWORD size
,available
;
701 if (!root
) drive
= DRIVE_GetCurrentDrive();
704 if ((root
[1]) && ((root
[1] != ':') || (root
[2] != '\\')))
706 WARN(dosfs
, "invalid root '%s'\n", root
);
709 drive
= toupper(root
[0]) - 'A';
711 if (!DRIVE_GetFreeSpace(drive
, &size
, &available
)) return FALSE
;
712 /*FIXME: Do we have the number of bytes available to the user? */
713 avail
->HighPart
= total
->HighPart
= 0;
714 avail
->LowPart
= available
;
715 total
->LowPart
= size
;
718 totalfree
->HighPart
=0;
719 totalfree
->LowPart
= available
;
724 /***********************************************************************
725 * GetDiskFreeSpaceEx32W (KERNEL32.873)
727 BOOL32 WINAPI
GetDiskFreeSpaceEx32W( LPCWSTR root
, LPULARGE_INTEGER avail
,
728 LPULARGE_INTEGER total
,
729 LPULARGE_INTEGER totalfree
)
734 xroot
= HEAP_strdupWtoA( GetProcessHeap(), 0, root
);
735 ret
= GetDiskFreeSpaceEx32A( xroot
, avail
, total
, totalfree
);
736 HeapFree( GetProcessHeap(), 0, xroot
);
740 /***********************************************************************
741 * GetDriveType16 (KERNEL.136)
743 UINT16 WINAPI
GetDriveType16( UINT16 drive
)
745 TRACE(dosfs
, "(%c:)\n", 'A' + drive
);
746 switch(DRIVE_GetType(drive
))
748 case TYPE_FLOPPY
: return DRIVE_REMOVABLE
;
749 case TYPE_HD
: return DRIVE_FIXED
;
750 case TYPE_CDROM
: return DRIVE_REMOVABLE
;
751 case TYPE_NETWORK
: return DRIVE_REMOTE
;
753 default: return DRIVE_CANNOTDETERMINE
;
758 /***********************************************************************
759 * GetDriveType32A (KERNEL32.208)
761 UINT32 WINAPI
GetDriveType32A( LPCSTR root
)
763 TRACE(dosfs
, "(%s)\n", root
);
764 if ((root
[1]) && (root
[1] != ':'))
766 WARN(dosfs
, "invalid root '%s'\n", root
);
767 return DRIVE_DOESNOTEXIST
;
769 switch(DRIVE_GetType(toupper(root
[0]) - 'A'))
771 case TYPE_FLOPPY
: return DRIVE_REMOVABLE
;
772 case TYPE_HD
: return DRIVE_FIXED
;
773 case TYPE_CDROM
: return DRIVE_CDROM
;
774 case TYPE_NETWORK
: return DRIVE_REMOTE
;
776 default: return DRIVE_CANNOTDETERMINE
;
781 /***********************************************************************
782 * GetDriveType32W (KERNEL32.209)
784 UINT32 WINAPI
GetDriveType32W( LPCWSTR root
)
786 LPSTR xpath
= HEAP_strdupWtoA( GetProcessHeap(), 0, root
);
787 UINT32 ret
= GetDriveType32A( xpath
);
788 HeapFree( GetProcessHeap(), 0, xpath
);
793 /***********************************************************************
794 * GetCurrentDirectory16 (KERNEL.411)
796 UINT16 WINAPI
GetCurrentDirectory16( UINT16 buflen
, LPSTR buf
)
798 return (UINT16
)GetCurrentDirectory32A( buflen
, buf
);
802 /***********************************************************************
803 * GetCurrentDirectory32A (KERNEL32.196)
805 * Returns "X:\\path\\etc\\".
807 * Despite the API description, return required length including the
808 * terminating null when buffer too small. This is the real behaviour.
810 UINT32 WINAPI
GetCurrentDirectory32A( UINT32 buflen
, LPSTR buf
)
813 const char *s
= DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() );
816 ret
= strlen(s
) + 3; /* length of WHOLE current directory */
817 if (ret
>= buflen
) return ret
+ 1;
818 lstrcpyn32A( buf
, "A:\\", MIN( 4, buflen
) );
819 if (buflen
) buf
[0] += DRIVE_GetCurrentDrive();
820 if (buflen
> 3) lstrcpyn32A( buf
+ 3, s
, buflen
- 3 );
825 /***********************************************************************
826 * GetCurrentDirectory32W (KERNEL32.197)
828 UINT32 WINAPI
GetCurrentDirectory32W( UINT32 buflen
, LPWSTR buf
)
830 LPSTR xpath
= HeapAlloc( GetProcessHeap(), 0, buflen
+1 );
831 UINT32 ret
= GetCurrentDirectory32A( buflen
, xpath
);
832 lstrcpyAtoW( buf
, xpath
);
833 HeapFree( GetProcessHeap(), 0, xpath
);
838 /***********************************************************************
839 * SetCurrentDirectory (KERNEL.412)
841 BOOL16 WINAPI
SetCurrentDirectory16( LPCSTR dir
)
843 return SetCurrentDirectory32A( dir
);
847 /***********************************************************************
848 * SetCurrentDirectory32A (KERNEL32.479)
850 BOOL32 WINAPI
SetCurrentDirectory32A( LPCSTR dir
)
852 int drive
= DRIVE_GetCurrentDrive();
854 if (dir
[0] && (dir
[1]==':'))
856 drive
= tolower( *dir
) - 'a';
857 if (!DRIVE_IsValid( drive
))
859 DOS_ERROR( ER_InvalidDrive
, EC_MediaError
, SA_Abort
, EL_Disk
);
864 /* FIXME: what about empty strings? Add a \\ ? */
865 if (!DRIVE_Chdir( drive
, dir
)) return FALSE
;
866 if (drive
== DRIVE_GetCurrentDrive()) return TRUE
;
867 return DRIVE_SetCurrentDrive( drive
);
871 /***********************************************************************
872 * SetCurrentDirectory32W (KERNEL32.480)
874 BOOL32 WINAPI
SetCurrentDirectory32W( LPCWSTR dirW
)
876 LPSTR dir
= HEAP_strdupWtoA( GetProcessHeap(), 0, dirW
);
877 BOOL32 res
= SetCurrentDirectory32A( dir
);
878 HeapFree( GetProcessHeap(), 0, dir
);
883 /***********************************************************************
884 * GetLogicalDriveStrings32A (KERNEL32.231)
886 UINT32 WINAPI
GetLogicalDriveStrings32A( UINT32 len
, LPSTR buffer
)
890 for (drive
= count
= 0; drive
< MAX_DOS_DRIVES
; drive
++)
891 if (DRIVE_IsValid(drive
)) count
++;
892 if (count
* 4 * sizeof(char) <= len
)
895 for (drive
= 0; drive
< MAX_DOS_DRIVES
; drive
++)
896 if (DRIVE_IsValid(drive
))
905 return count
* 4 * sizeof(char);
909 /***********************************************************************
910 * GetLogicalDriveStrings32W (KERNEL32.232)
912 UINT32 WINAPI
GetLogicalDriveStrings32W( UINT32 len
, LPWSTR buffer
)
916 for (drive
= count
= 0; drive
< MAX_DOS_DRIVES
; drive
++)
917 if (DRIVE_IsValid(drive
)) count
++;
918 if (count
* 4 * sizeof(WCHAR
) <= len
)
921 for (drive
= 0; drive
< MAX_DOS_DRIVES
; drive
++)
922 if (DRIVE_IsValid(drive
))
924 *p
++ = (WCHAR
)('a' + drive
);
931 return count
* 4 * sizeof(WCHAR
);
935 /***********************************************************************
936 * GetLogicalDrives (KERNEL32.233)
938 DWORD WINAPI
GetLogicalDrives(void)
943 for (drive
= 0; drive
< MAX_DOS_DRIVES
; drive
++)
944 if (DRIVE_IsValid(drive
)) ret
|= (1 << drive
);
949 /***********************************************************************
950 * GetVolumeInformation32A (KERNEL32.309)
952 BOOL32 WINAPI
GetVolumeInformation32A( LPCSTR root
, LPSTR label
,
953 DWORD label_len
, DWORD
*serial
,
954 DWORD
*filename_len
, DWORD
*flags
,
955 LPSTR fsname
, DWORD fsname_len
)
959 /* FIXME, SetLastErrors missing */
961 if (!root
) drive
= DRIVE_GetCurrentDrive();
964 if ((root
[1]) && (root
[1] != ':'))
966 WARN(dosfs
, "invalid root '%s'\n",root
);
969 drive
= toupper(root
[0]) - 'A';
971 if (!DRIVE_IsValid( drive
)) return FALSE
;
972 if (label
) lstrcpyn32A( label
, DOSDrives
[drive
].label
, label_len
);
973 if (serial
) *serial
= DOSDrives
[drive
].serial
;
975 /* Set the filesystem information */
976 /* Note: we only emulate a FAT fs at the present */
978 if (filename_len
) *filename_len
= 12;
979 if (flags
) *flags
= 0;
981 /* Diablo checks that return code ... */
982 if (DRIVE_GetType(drive
)==TYPE_CDROM
)
983 lstrcpyn32A( fsname
, "CDFS", fsname_len
);
985 lstrcpyn32A( fsname
, "FAT", fsname_len
);
991 /***********************************************************************
992 * GetVolumeInformation32W (KERNEL32.310)
994 BOOL32 WINAPI
GetVolumeInformation32W( LPCWSTR root
, LPWSTR label
,
995 DWORD label_len
, DWORD
*serial
,
996 DWORD
*filename_len
, DWORD
*flags
,
997 LPWSTR fsname
, DWORD fsname_len
)
999 LPSTR xroot
= HEAP_strdupWtoA( GetProcessHeap(), 0, root
);
1000 LPSTR xvolname
= label
? HeapAlloc(GetProcessHeap(),0,label_len
) : NULL
;
1001 LPSTR xfsname
= fsname
? HeapAlloc(GetProcessHeap(),0,fsname_len
) : NULL
;
1002 BOOL32 ret
= GetVolumeInformation32A( xroot
, xvolname
, label_len
, serial
,
1003 filename_len
, flags
, xfsname
,
1007 if (label
) lstrcpyAtoW( label
, xvolname
);
1008 if (fsname
) lstrcpyAtoW( fsname
, xfsname
);
1010 HeapFree( GetProcessHeap(), 0, xroot
);
1011 HeapFree( GetProcessHeap(), 0, xvolname
);
1012 HeapFree( GetProcessHeap(), 0, xfsname
);