source: trunk/src/kernel32/disk.cpp@ 3620

Last change on this file since 3620 was 3620, checked in by sandervl, 25 years ago

fixed bugs in GetVolumeInformationA
File size: 13.0 KB
Line 
1/* $Id: disk.cpp,v 1.13 2000-05-28 11:41:44 sandervl Exp $ */
2
3/*
4 * Win32 Disk API functions for OS/2
5 *
6 * Copyright 1998 Sander van Leeuwen
7 *
8 *
9 * Project Odin Software License can be found in LICENSE.TXT
10 *
11 */
12
13
14#include <odin.h>
15#include <odinwrap.h>
16#include <os2sel.h>
17
18#include <os2win.h>
19#include <stdlib.h>
20#include <string.h>
21#include "unicode.h"
22#include "oslibdos.h"
23
24#define DBG_LOCALLOG DBG_disk
25#include "dbglocal.h"
26
27
28ODINDEBUGCHANNEL(KERNEL32-DISK)
29
30//******************************************************************************
31//******************************************************************************
32BOOL WIN32API SetVolumeLabelA( LPCSTR arg1, LPCSTR arg2)
33{
34 dprintf(("KERNEL32: OS2SetVolumeLabelA\n"));
35 return O32_SetVolumeLabel(arg1, arg2);
36}
37//******************************************************************************
38//******************************************************************************
39BOOL WIN32API SetVolumeLabelW(LPCWSTR lpRootPathName, LPCWSTR lpVolumeName)
40{
41 char *asciiroot, *asciivolname;
42 BOOL rc;
43
44 dprintf(("KERNEL32: OS2SetVolumeLabelW\n"));
45 asciiroot = UnicodeToAsciiString((LPWSTR)lpRootPathName);
46 asciivolname = UnicodeToAsciiString((LPWSTR)lpVolumeName);
47 rc = O32_SetVolumeLabel(asciiroot, asciivolname);
48 FreeAsciiString(asciivolname);
49 FreeAsciiString(asciiroot);
50 return(rc);
51}
52
53//******************************************************************************
54//SvL: 24-6-'97 - Added
55//******************************************************************************
56BOOL WIN32API GetDiskFreeSpaceA( LPCSTR arg1, PDWORD arg2, PDWORD arg3, PDWORD arg4, PDWORD arg5)
57{
58 BOOL rc;
59 DWORD dwSectorsPerCluster; // address of sectors per cluster ter
60 DWORD dwBytesPerSector; // address of bytes per sector
61 DWORD dwNumberOfFreeClusters; // address of number of free clusters
62 DWORD dwTotalNumberOfClusters; // address of total number of clusters
63 dprintf(("KERNEL32: OS2GetDiskFreeSpaceA %s, 0x%08X, 0x%08X, 0x%08X, 0x%08X,\n",
64 arg1!=NULL?arg1:"NULL", arg2,arg3,arg4,arg5));
65 rc = O32_GetDiskFreeSpace(arg1, &dwSectorsPerCluster, &dwBytesPerSector,
66 &dwNumberOfFreeClusters, &dwTotalNumberOfClusters);
67 if(rc)
68 {
69 if (arg2!=NULL)
70 *arg2 = dwSectorsPerCluster;
71 if (arg3!=NULL)
72 *arg3 = dwBytesPerSector;
73 if (arg4!=NULL)
74 *arg4 = dwNumberOfFreeClusters;
75 if (arg5!=NULL)
76 *arg5 = dwTotalNumberOfClusters;
77 }
78 dprintf((" returned %d\n",rc));
79 return rc;
80}
81//******************************************************************************
82//******************************************************************************
83BOOL WIN32API GetDiskFreeSpaceW(LPCWSTR arg1, PDWORD arg2, PDWORD arg3, PDWORD arg4, PDWORD arg5)
84{
85 BOOL rc;
86 char *astring;
87
88 dprintf(("KERNEL32: OS2GetDiskFreeSpaceW\n"));
89 astring = UnicodeToAsciiString((LPWSTR)arg1);
90 rc = O32_GetDiskFreeSpace(astring, arg2, arg3, arg4, arg5);
91 FreeAsciiString(astring);
92 return(rc);
93}
94
95
96/*****************************************************************************
97 * Name : GetDiskFreeSpaceEx
98 * Purpose :
99 * Parameters: lpDirectoryName [in] Pointer to a null-terminated string that
100 * specifies a directory on the disk of interest.
101 * This string can be a UNC name. If this
102 * parameter is a UNC name, you must follow it
103 * with an additional backslash. For example, you
104 * would specify \\MyServer\MyShare as
105 * \\MyServer\MyShare\.
106 * If lpDirectoryName is NULL, the
107 * GetDiskFreeSpaceEx function obtains
108 * information about the object store.
109 * Note that lpDirectoryName does not have to
110 * specify the root directory on a disk. The
111 * function accepts any directory on the disk.
112 *
113 * lpFreeBytesAvailableToCaller
114 * [out] Pointer to a variable to receive the
115 * total number of free bytes on the disk that
116 * are available to the user associated with the
117 * calling thread.
118 * lpTotalNumberOfBytes
119 * [out] Pointer to a variable to receive the
120 * total number of bytes on the disk that are
121 * available to the user associated with the
122 * calling thread.
123 * lpTotalNumberOfFreeBytes
124 * [out] Pointer to a variable to receive the
125 * total number of free bytes on the disk.
126 * This parameter can be NULL.
127 * Variables :
128 * Result : Nonzero indicates success. Zero indicates failure. To get
129 * extended error information, call GetLastError.
130 * Remark : Note that the values obtained by this function are of type
131 * ULARGE_INTEGER. Be careful not to truncate these values to
132 * 32 bits.
133 * Status :
134 *
135 * Author : Patrick Haller [Fri, 2000/01/08 23:44]
136 *****************************************************************************/
137
138ODINFUNCTION4(BOOL,GetDiskFreeSpaceExA,
139 LPCSTR, lpDirectoryName,
140 PULARGE_INTEGER, lpFreeBytesAvailableToCaller,
141 PULARGE_INTEGER, lpTotalNumberOfBytes,
142 PULARGE_INTEGER, lpTotalNumberOfFreeBytes )
143{
144 BOOL rc;
145 DWORD dwSectorsPerCluster; // address of sectors per cluster ter
146 DWORD dwBytesPerSector; // address of bytes per sector
147 DWORD dwNumberOfFreeClusters; // address of number of free clusters
148 DWORD dwTotalNumberOfClusters; // address of total number of clusters
149
150 rc = O32_GetDiskFreeSpace(lpDirectoryName, &dwSectorsPerCluster, &dwBytesPerSector,
151 &dwNumberOfFreeClusters, &dwTotalNumberOfClusters);
152 if(rc)
153 {
154 //TODO: Fill in high part (overflow possible)!!!!!!
155 if(lpFreeBytesAvailableToCaller!=NULL) {
156 lpFreeBytesAvailableToCaller->LowPart = dwNumberOfFreeClusters*dwSectorsPerCluster*dwBytesPerSector;
157 lpFreeBytesAvailableToCaller->HighPart = 0;
158 }
159 if(lpTotalNumberOfBytes!=NULL) {
160 lpTotalNumberOfBytes->LowPart = dwTotalNumberOfClusters*dwSectorsPerCluster*dwBytesPerSector;
161 lpTotalNumberOfBytes->HighPart = 0;
162 }
163 if(lpTotalNumberOfFreeBytes!=NULL) {
164 lpTotalNumberOfFreeBytes->LowPart = dwNumberOfFreeClusters*dwSectorsPerCluster*dwBytesPerSector;
165 lpTotalNumberOfFreeBytes->HighPart = 0;
166 }
167 }
168 return rc;
169}
170
171
172ODINFUNCTION4(BOOL,GetDiskFreeSpaceExW,
173 LPCWSTR, lpDirectoryName,
174 PULARGE_INTEGER, lpFreeBytesAvailableToCaller,
175 PULARGE_INTEGER, lpTotalNumberOfBytes,
176 PULARGE_INTEGER, lpTotalNumberOfFreeBytes )
177{
178 BOOL rc;
179 char *astring;
180
181 dprintf(("KERNEL32: OS2GetDiskFreeSpaceExW\n"));
182 astring = UnicodeToAsciiString((LPWSTR)lpDirectoryName);
183 rc = GetDiskFreeSpaceExA(astring, lpFreeBytesAvailableToCaller, lpTotalNumberOfBytes, lpTotalNumberOfFreeBytes);
184 FreeAsciiString(astring);
185 return(rc);
186}
187
188
189//******************************************************************************
190//******************************************************************************
191UINT WIN32API GetDriveTypeA( LPCSTR arg1)
192{
193 UINT rc;
194 rc = O32_GetDriveType(arg1);
195 dprintf(("KERNEL32: GetDriveType %s = %d\n", arg1,rc));
196 return rc;
197}
198//******************************************************************************
199//******************************************************************************
200UINT WIN32API GetDriveTypeW(LPCWSTR arg1)
201{
202 UINT rc;
203 char *astring;
204
205 astring = UnicodeToAsciiString((LPWSTR)arg1);
206 dprintf(("KERNEL32: OS2GetDriveTypeW %s", astring));
207 rc = O32_GetDriveType(astring);
208 FreeAsciiString(astring);
209 return(rc);
210}
211//******************************************************************************
212//******************************************************************************
213ODINFUNCTION8(BOOL, GetVolumeInformationA,
214 LPCSTR, lpRootPathName,
215 LPSTR, lpVolumeNameBuffer,
216 DWORD, nVolumeNameSize,
217 PDWORD, lpVolumeSerialNumber,
218 PDWORD, lpMaximumComponentLength,
219 PDWORD, lpFileSystemFlags,
220 LPSTR, lpFileSystemNameBuffer,
221 DWORD, nFileSystemNameSize)
222{
223 CHAR tmpstring[256];
224 ULONG drive;
225 BOOL rc;
226
227 dprintf(("GetVolumeInformationA %s", lpRootPathName));
228
229 if(lpRootPathName == NULL) {
230 GetCurrentDirectoryA(sizeof(tmpstring), tmpstring);
231 lpRootPathName = tmpstring;
232 }
233
234 if('A' <= *lpRootPathName && *lpRootPathName <= 'Z') {
235 drive = *lpRootPathName - 'A' + 1;
236 }
237 else
238 if('a' <= *lpRootPathName && *lpRootPathName <= 'z') {
239 drive = *lpRootPathName - 'a' + 1;
240 }
241 else {
242 SetLastError(ERROR_INVALID_PARAMETER);
243 return FALSE;
244 }
245
246 if(lpVolumeSerialNumber || lpVolumeNameBuffer) {
247 rc = OSLibDosQueryVolumeSerialAndName(drive, lpVolumeSerialNumber, lpVolumeNameBuffer, nVolumeNameSize);
248 }
249 if(lpFileSystemNameBuffer || lpMaximumComponentLength) {
250 if(!lpFileSystemNameBuffer) {
251 lpFileSystemNameBuffer = tmpstring;
252 nFileSystemNameSize = sizeof(tmpstring);
253 }
254 rc = OSLibDosQueryVolumeFS(drive, lpFileSystemNameBuffer, nFileSystemNameSize);
255 }
256 if(lpMaximumComponentLength) {
257 if(!strcmp(lpFileSystemNameBuffer, "FAT")) {
258 *lpMaximumComponentLength = 12;
259 }
260 else *lpMaximumComponentLength = 255; //TODO: Always correct? (CDFS?)
261 }
262 if(lpFileSystemFlags) {
263 if(strcmp(lpFileSystemNameBuffer, "FAT")) {
264 *lpFileSystemFlags = FS_CASE_IS_PRESERVED;
265 }
266 else
267 if(!strcmp(lpFileSystemNameBuffer, "CDFS")) {
268 *lpFileSystemFlags = FS_CASE_SENSITIVE; //NT4 returns this
269 }
270 else
271 if(!strcmp(lpFileSystemNameBuffer, "UDF")) {//TODO: correct?
272 *lpFileSystemFlags = FS_CASE_SENSITIVE | FS_UNICODE_STORED_ON_DISK;
273 }
274 else *lpFileSystemFlags = 0;
275 }
276
277 if(rc) {
278 SetLastError(rc);
279 return FALSE;
280 }
281 return TRUE;
282}
283//******************************************************************************
284//******************************************************************************
285ODINFUNCTION8(BOOL, GetVolumeInformationW,
286 LPCWSTR, lpRootPathName,
287 LPWSTR, lpVolumeNameBuffer,
288 DWORD, nVolumeNameSize,
289 PDWORD, lpVolumeSerialNumber,
290 PDWORD, lpMaximumComponentLength,
291 PDWORD, lpFileSystemFlags,
292 LPWSTR, lpFileSystemNameBuffer,
293 DWORD, nFileSystemNameSize)
294{
295 char *asciiroot,
296 *asciivol,
297 *asciifs;
298 BOOL rc;
299
300 // transform into ascii
301 asciivol = (char *)malloc(nVolumeNameSize+1);
302 asciifs = (char *)malloc(nFileSystemNameSize+1);
303
304 // clear ascii buffers
305 memset (asciivol, 0, (nVolumeNameSize + 1));
306 memset (asciifs, 0, (nFileSystemNameSize + 1));
307
308 if (lpRootPathName != NULL) // NULL is valid!
309 asciiroot = UnicodeToAsciiString((LPWSTR)lpRootPathName);
310 else
311 asciiroot = NULL;
312
313 rc = ODIN_GetVolumeInformationA(asciiroot,
314 asciivol,
315 nVolumeNameSize,
316 lpVolumeSerialNumber,
317 lpMaximumComponentLength,
318 lpFileSystemFlags,
319 asciifs,
320 nFileSystemNameSize);
321
322 if (lpVolumeNameBuffer != NULL) /* @@@PH 98/06/07 */
323 AsciiToUnicodeN(asciivol, lpVolumeNameBuffer, nVolumeNameSize);
324
325 if (lpFileSystemNameBuffer != NULL) /* @@@PH 98/06/07 */
326 AsciiToUnicodeN(asciifs, lpFileSystemNameBuffer, nFileSystemNameSize);
327
328
329 if (asciiroot != NULL)
330 FreeAsciiString(asciiroot);
331
332 free(asciifs);
333 free(asciivol);
334 return(rc);
335}
336//******************************************************************************
337//******************************************************************************
338DWORD WIN32API GetLogicalDrives(void)
339{
340 dprintf(("KERNEL32: GetLogicalDrives\n"));
341 return O32_GetLogicalDrives();
342}
343//******************************************************************************
344//******************************************************************************
345UINT WIN32API GetLogicalDriveStringsA(UINT arg1, LPSTR arg2)
346{
347 dprintf(("KERNEL32: OS2GetLogicalDriveStringsA\n"));
348 return O32_GetLogicalDriveStrings(arg1, arg2);
349}
350//******************************************************************************
351//******************************************************************************
352UINT WIN32API GetLogicalDriveStringsW(UINT nBufferLength, LPWSTR lpBuffer)
353{
354 char *asciibuffer = (char *)malloc(nBufferLength+1);
355 DWORD rc;
356
357 dprintf(("KERNEL32: OS2GetLogicalDriveStringsW\n"));
358
359 rc = O32_GetLogicalDriveStrings(nBufferLength, asciibuffer);
360 if(rc) AsciiToUnicode(asciibuffer, lpBuffer);
361 free(asciibuffer);
362 return(rc);
363}
Note: See TracBrowser for help on using the repository browser.