Context Navigation

source: trunk/src/kernel32/hmdisk.cpp@ 6086

Visit:

Last change on this file since 6086 was 6086, checked in by sandervl, 24 years ago
added cdrom get/setvolume ioctls
File size: 27.1 KB

Line
1	/* $Id: hmdisk.cpp,v 1.12 2001-06-23 19:43:50 sandervl Exp $ */
2
3	/*
4	* Win32 Disk API functions for OS/2
5	*
6	* Copyright 2000 Sander van Leeuwen
7	*
8	*
9	* Project Odin Software License can be found in LICENSE.TXT
10	*
11	*/
12	#include <os2win.h>
13	#include <string.h>
14
15	#include <misc.h>
16	#include "hmdisk.h"
17	#include "mmap.h"
18	#include "oslibdos.h"
19	#include <win\winioctl.h>
20	#include <win\ntddscsi.h>
21	#include <win\wnaspi32.h>
22	#include <win\aspi.h>
23
24	#define DBG_LOCALLOG DBG_hmdisk
25	#include "dbglocal.h"
26
27	typedef struct
28	{
29	HINSTANCE hInstAspi;
30	DWORD (WIN32API *GetASPI32SupportInfo)();
31	DWORD (CDECL *SendASPI32Command)(LPSRB lpSRB);
32	ULONG driveLetter;
33	CHAR signature[8];
34	} DRIVE_INFO;
35
36	HMDeviceDiskClass::HMDeviceDiskClass(LPCSTR lpDeviceName) : HMDeviceKernelObjectClass(lpDeviceName)
37	{
38	HMDeviceRegisterEx("\\\\.\\PHYSICALDRIVE", this, NULL);
39	}
40
41	/*****************************************************************************
42	* Name : HMDeviceDiskClass::FindDevice
43	* Purpose : Checks if lpDeviceName belongs to this device class
44	* Parameters: LPCSTR lpClassDevName
45	* LPCSTR lpDeviceName
46	* int namelength
47	* Variables :
48	* Result : checks if name is for a drive of physical disk
49	* Remark :
50	* Status :
51	*
52	* Author : SvL
53	*****************************************************************************/
54	BOOL HMDeviceDiskClass::FindDevice(LPCSTR lpClassDevName, LPCSTR lpDeviceName, int namelength)
55	{
56	//\\.\x: -> length 6
57	//\\.\PHYSICALDRIVEn -> length 18
58	if(namelength != 6 && namelength != 18) {
59	return FALSE;
60	}
61
62	//SvL: \\.\x: -> drive x (i.e. \\.\C:)
63	// \\.\PHYSICALDRIVEn -> drive n (n>=0)
64	if((strncmp(lpDeviceName, "\\\\.\\", 4) == 0) &&
65	namelength == 6 && lpDeviceName[5] == ':')
66	{
67	return TRUE;
68	}
69	if((strncmp(lpDeviceName, "\\\\.\\PHYSICALDRIVE", 17) == 0) && namelength == 18) {
70	return TRUE;
71	}
72	return FALSE;
73	}
74	//******************************************************************************
75	//TODO: PHYSICALDRIVEn!!
76	//******************************************************************************
77	DWORD HMDeviceDiskClass::CreateFile (LPCSTR lpFileName,
78	PHMHANDLEDATA pHMHandleData,
79	PVOID lpSecurityAttributes,
80	PHMHANDLEDATA pHMHandleDataTemplate)
81	{
82	HFILE hFile;
83	HFILE hTemplate;
84
85	dprintf2(("KERNEL32: HMDeviceDiskClass::CreateFile %s(%s,%08x,%08x,%08x)\n",
86	lpHMDeviceName,
87	lpFileName,
88	pHMHandleData,
89	lpSecurityAttributes,
90	pHMHandleDataTemplate));
91
92	//TODO: check in NT if CREATE_ALWAYS is allowed!!
93	if(pHMHandleData->dwCreation != OPEN_EXISTING) {
94	dprintf(("Invalid creation flags %x!!", pHMHandleData->dwCreation));
95	return ERROR_INVALID_PARAMETER;
96	}
97	if(strncmp(lpFileName, // "support" for local unc names
98	"\\\\.\\",
99	4) == 0)
100	{
101	lpFileName+=4;
102	}
103
104	//Disable error popus. NT allows an app to open a cdrom/dvd drive without a disk inside
105	//OS/2 fails in that case with error ERROR_NOT_READY
106	OSLibDosDisableHardError(TRUE);
107	hFile = OSLibDosCreateFile((LPSTR)lpFileName,
108	pHMHandleData->dwAccess,
109	pHMHandleData->dwShare,
110	(LPSECURITY_ATTRIBUTES)lpSecurityAttributes,
111	pHMHandleData->dwCreation,
112	pHMHandleData->dwFlags,
113	hTemplate);
114	OSLibDosDisableHardError(FALSE);
115
116	if (hFile != INVALID_HANDLE_ERROR \|\| GetLastError() == ERROR_NOT_READY)
117	{
118	if(hFile == INVALID_HANDLE_ERROR) {
119	SetLastError(NO_ERROR);
120	pHMHandleData->hHMHandle = 0; //handle lookup fails if this is set to -1
121	}
122	else pHMHandleData->hHMHandle = hFile;
123
124	DRIVE_INFO drvInfo = (DRIVE_INFO )malloc(sizeof(DRIVE_INFO));
125	if(drvInfo == NULL) {
126	if(pHMHandleData->hHMHandle) OSLibDosClose(pHMHandleData->hHMHandle);
127	return ERROR_OUTOFMEMORY;
128	}
129	pHMHandleData->dwUserData = (DWORD)drvInfo;
130
131	memset(drvInfo, 0, sizeof(DRIVE_INFO));
132	drvInfo->driveLetter = *lpFileName; //save drive letter
133	if(drvInfo->driveLetter >= 'a') {
134	drvInfo->driveLetter = drvInfo->driveLetter - ((int)'a' - (int)'A');
135	}
136
137	if(GetDriveTypeA(lpFileName) == DRIVE_CDROM) {
138	drvInfo->hInstAspi = LoadLibraryA("WNASPI32.DLL");
139	if(drvInfo->hInstAspi == NULL) {
140	if(pHMHandleData->hHMHandle) OSLibDosClose(pHMHandleData->hHMHandle);
141	free(drvInfo);
142	return ERROR_INVALID_PARAMETER;
143	}
144	(FARPROC )&drvInfo->GetASPI32SupportInfo = GetProcAddress(drvInfo->hInstAspi, "GetASPI32SupportInfo");
145	(FARPROC )&drvInfo->SendASPI32Command = GetProcAddress(drvInfo->hInstAspi, "SendASPI32Command");
146
147	//get cdrom signature (TODO: why doesn't this work???)
148	DWORD parsize = 4;
149	DWORD datasize = 4;
150	strcpy(drvInfo->signature, "CD01");
151	OSLibDosDevIOCtl(pHMHandleData->hHMHandle, 0x81, 0x60, &drvInfo->signature[0], 4, &parsize,
152	&drvInfo->signature[0], 4, &datasize);
153	}
154	return (NO_ERROR);
155	}
156	else {
157	dprintf(("CreateFile failed; error %d", GetLastError()));
158	return(GetLastError());
159	}
160	}
161	//******************************************************************************
162	//******************************************************************************
163	BOOL HMDeviceDiskClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
164	{
165	BOOL ret = TRUE;
166
167	if(pHMHandleData->hHMHandle) {
168	ret = OSLibDosClose(pHMHandleData->hHMHandle);
169	}
170	if(pHMHandleData->dwUserData) {
171	DRIVE_INFO drvInfo = (DRIVE_INFO)pHMHandleData->dwUserData;
172	if(drvInfo->hInstAspi) FreeLibrary(drvInfo->hInstAspi);
173	free(drvInfo);
174	}
175	return ret;
176	}
177	//******************************************************************************
178	//******************************************************************************
179	BOOL HMDeviceDiskClass::DeviceIoControl(PHMHANDLEDATA pHMHandleData, DWORD dwIoControlCode,
180	LPVOID lpInBuffer, DWORD nInBufferSize,
181	LPVOID lpOutBuffer, DWORD nOutBufferSize,
182	LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
183	{
184	#ifdef DEBUG
185	char *msg = NULL;
186
187	switch(dwIoControlCode)
188	{
189	case FSCTL_DELETE_REPARSE_POINT:
190	msg = "FSCTL_DELETE_REPARSE_POINT";
191	break;
192	case FSCTL_DISMOUNT_VOLUME:
193	msg = "FSCTL_DISMOUNT_VOLUME";
194	break;
195	case FSCTL_GET_COMPRESSION:
196	msg = "FSCTL_GET_COMPRESSION";
197	break;
198	case FSCTL_GET_REPARSE_POINT:
199	msg = "FSCTL_GET_REPARSE_POINT";
200	break;
201	case FSCTL_LOCK_VOLUME:
202	msg = "FSCTL_LOCK_VOLUME";
203	break;
204	case FSCTL_QUERY_ALLOCATED_RANGES:
205	msg = "FSCTL_QUERY_ALLOCATED_RANGES";
206	break;
207	case FSCTL_SET_COMPRESSION:
208	msg = "FSCTL_SET_COMPRESSION";
209	break;
210	case FSCTL_SET_REPARSE_POINT:
211	msg = "FSCTL_SET_REPARSE_POINT";
212	break;
213	case FSCTL_SET_SPARSE:
214	msg = "FSCTL_SET_SPARSE";
215	break;
216	case FSCTL_SET_ZERO_DATA:
217	msg = "FSCTL_SET_ZERO_DATA";
218	break;
219	case FSCTL_UNLOCK_VOLUME:
220	msg = "FSCTL_UNLOCK_VOLUME";
221	break;
222	case IOCTL_DISK_CHECK_VERIFY:
223	msg = "IOCTL_DISK_CHECK_VERIFY";
224	break;
225	case IOCTL_DISK_EJECT_MEDIA:
226	msg = "IOCTL_DISK_EJECT_MEDIA";
227	break;
228	case IOCTL_DISK_FORMAT_TRACKS:
229	msg = "IOCTL_DISK_FORMAT_TRACKS";
230	break;
231	case IOCTL_DISK_GET_DRIVE_GEOMETRY:
232	msg = "IOCTL_DISK_GET_DRIVE_GEOMETRY";
233	break;
234	case IOCTL_DISK_GET_DRIVE_LAYOUT:
235	msg = "IOCTL_DISK_GET_DRIVE_LAYOUT";
236	break;
237	case IOCTL_DISK_GET_MEDIA_TYPES:
238	msg = "IOCTL_DISK_GET_MEDIA_TYPES";
239	break;
240	case IOCTL_DISK_GET_PARTITION_INFO:
241	msg = "IOCTL_DISK_GET_PARTITION_INFO";
242	break;
243	case IOCTL_DISK_LOAD_MEDIA:
244	msg = "IOCTL_DISK_LOAD_MEDIA";
245	break;
246	case IOCTL_DISK_MEDIA_REMOVAL:
247	msg = "IOCTL_DISK_MEDIA_REMOVAL";
248	break;
249	case IOCTL_DISK_PERFORMANCE:
250	msg = "IOCTL_DISK_PERFORMANCE";
251	break;
252	case IOCTL_DISK_REASSIGN_BLOCKS:
253	msg = "IOCTL_DISK_REASSIGN_BLOCKS";
254	break;
255	case IOCTL_DISK_SET_DRIVE_LAYOUT:
256	msg = "IOCTL_DISK_SET_DRIVE_LAYOUT";
257	break;
258	case IOCTL_DISK_SET_PARTITION_INFO:
259	msg = "IOCTL_DISK_SET_PARTITION_INFO";
260	break;
261	case IOCTL_DISK_VERIFY:
262	msg = "IOCTL_DISK_VERIFY";
263	break;
264	case IOCTL_SERIAL_LSRMST_INSERT:
265	msg = "IOCTL_SERIAL_LSRMST_INSERT";
266	break;
267	case IOCTL_STORAGE_CHECK_VERIFY:
268	msg = "IOCTL_STORAGE_CHECK_VERIFY";
269	break;
270	case IOCTL_STORAGE_EJECT_MEDIA:
271	msg = "IOCTL_STORAGE_EJECT_MEDIA";
272	break;
273	case IOCTL_STORAGE_GET_MEDIA_TYPES:
274	msg = "IOCTL_STORAGE_GET_MEDIA_TYPES";
275	break;
276	case IOCTL_STORAGE_LOAD_MEDIA:
277	msg = "IOCTL_STORAGE_LOAD_MEDIA";
278	break;
279	case IOCTL_STORAGE_MEDIA_REMOVAL:
280	msg = "IOCTL_STORAGE_MEDIA_REMOVAL";
281	break;
282	case IOCTL_SCSI_PASS_THROUGH:
283	msg = "IOCTL_SCSI_PASS_THROUGH";
284	break;
285	case IOCTL_SCSI_MINIPORT:
286	msg = "IOCTL_SCSI_MINIPORT";
287	break;
288	case IOCTL_SCSI_GET_INQUIRY_DATA:
289	msg = "IOCTL_SCSI_GET_INQUIRY_DATA";
290	break;
291	case IOCTL_SCSI_GET_CAPABILITIES:
292	msg = "IOCTL_SCSI_GET_CAPABILITIES";
293	break;
294	case IOCTL_SCSI_PASS_THROUGH_DIRECT:
295	msg = "IOCTL_SCSI_PASS_THROUGH_DIRECT";
296	break;
297	case IOCTL_SCSI_GET_ADDRESS:
298	msg = "IOCTL_SCSI_GET_ADDRESS";
299	break;
300	case IOCTL_SCSI_RESCAN_BUS:
301	msg = "IOCTL_SCSI_RESCAN_BUS";
302	break;
303	case IOCTL_SCSI_GET_DUMP_POINTERS:
304	msg = "IOCTL_SCSI_GET_DUMP_POINTERS";
305	break;
306	case IOCTL_SCSI_FREE_DUMP_POINTERS:
307	msg = "IOCTL_SCSI_FREE_DUMP_POINTERS";
308	break;
309	case IOCTL_IDE_PASS_THROUGH:
310	msg = "IOCTL_IDE_PASS_THROUGH";
311	break;
312	case IOCTL_CDROM_UNLOAD_DRIVER:
313	msg = "IOCTL_CDROM_UNLOAD_DRIVER";
314	break;
315	case IOCTL_CDROM_READ_TOC:
316	msg = "IOCTL_CDROM_READ_TOC";
317	break;
318	case IOCTL_CDROM_GET_CONTROL:
319	msg = "IOCTL_CDROM_GET_CONTROL";
320	break;
321	case IOCTL_CDROM_PLAY_AUDIO_MSF:
322	msg = "IOCTL_CDROM_PLAY_AUDIO_MSF";
323	break;
324	case IOCTL_CDROM_SEEK_AUDIO_MSF:
325	msg = "IOCTL_CDROM_SEEK_AUDIO_MSF";
326	break;
327	case IOCTL_CDROM_STOP_AUDIO:
328	msg = "IOCTL_CDROM_STOP_AUDIO";
329	break;
330	case IOCTL_CDROM_PAUSE_AUDIO:
331	msg = "IOCTL_CDROM_PAUSE_AUDIO";
332	break;
333	case IOCTL_CDROM_RESUME_AUDIO:
334	msg = "IOCTL_CDROM_RESUME_AUDIO";
335	break;
336	case IOCTL_CDROM_GET_VOLUME:
337	msg = "IOCTL_CDROM_GET_VOLUME";
338	break;
339	case IOCTL_CDROM_SET_VOLUME:
340	msg = "IOCTL_CDROM_SET_VOLUME";
341	break;
342	case IOCTL_CDROM_READ_Q_CHANNEL:
343	msg = "IOCTL_CDROM_READ_Q_CHANNEL";
344	break;
345	case IOCTL_CDROM_GET_LAST_SESSION:
346	msg = "IOCTL_CDROM_GET_LAST_SESSION";
347	break;
348	case IOCTL_CDROM_RAW_READ:
349	msg = "IOCTL_CDROM_RAW_READ";
350	break;
351	case IOCTL_CDROM_DISK_TYPE:
352	msg = "IOCTL_CDROM_DISK_TYPE";
353	break;
354	case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
355	msg = "IOCTL_CDROM_GET_DRIVE_GEOMETRY";
356	break;
357	case IOCTL_CDROM_CHECK_VERIFY:
358	msg = "IOCTL_CDROM_CHECK_VERIFY";
359	break;
360	case IOCTL_CDROM_MEDIA_REMOVAL:
361	msg = "IOCTL_CDROM_MEDIA_REMOVAL";
362	break;
363	case IOCTL_CDROM_EJECT_MEDIA:
364	msg = "IOCTL_CDROM_EJECT_MEDIA";
365	break;
366	case IOCTL_CDROM_LOAD_MEDIA:
367	msg = "IOCTL_CDROM_LOAD_MEDIA";
368	break;
369	case IOCTL_CDROM_RESERVE:
370	msg = "IOCTL_CDROM_RESERVE";
371	break;
372	case IOCTL_CDROM_RELEASE:
373	msg = "IOCTL_CDROM_RELEASE";
374	break;
375	case IOCTL_CDROM_FIND_NEW_DEVICES:
376	msg = "IOCTL_CDROM_FIND_NEW_DEVICES";
377	break;
378	}
379	if(msg) {
380	dprintf(("HMDeviceDiskClass::DeviceIoControl %s %x %d %x %d %x %x", msg, lpInBuffer, nInBufferSize,
381	lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped));
382	}
383	#endif
384
385	DRIVE_INFO drvInfo = (DRIVE_INFO)pHMHandleData->dwUserData;
386	if(drvInfo == NULL) {
387	dprintf(("ERROR: DeviceIoControl: drvInfo == NULL!!!"));
388	DebugInt3();
389	SetLastError(ERROR_INVALID_HANDLE);
390	return FALSE;
391	}
392	switch(dwIoControlCode)
393	{
394	case FSCTL_DELETE_REPARSE_POINT:
395	case FSCTL_DISMOUNT_VOLUME:
396	case FSCTL_GET_COMPRESSION:
397	case FSCTL_GET_REPARSE_POINT:
398	case FSCTL_LOCK_VOLUME:
399	case FSCTL_QUERY_ALLOCATED_RANGES:
400	case FSCTL_SET_COMPRESSION:
401	case FSCTL_SET_REPARSE_POINT:
402	case FSCTL_SET_SPARSE:
403	case FSCTL_SET_ZERO_DATA:
404	case FSCTL_UNLOCK_VOLUME:
405	break;
406
407	case IOCTL_DISK_CHECK_VERIFY:
408	case IOCTL_DISK_EJECT_MEDIA:
409	case IOCTL_DISK_FORMAT_TRACKS:
410	case IOCTL_DISK_GET_DRIVE_LAYOUT:
411	break;
412
413	case IOCTL_DISK_GET_DRIVE_GEOMETRY:
414	case IOCTL_DISK_GET_MEDIA_TYPES:
415	{
416	PDISK_GEOMETRY pGeom = (PDISK_GEOMETRY)lpOutBuffer;
417	if(nOutBufferSize < sizeof(DISK_GEOMETRY) \|\| !pGeom) {
418	SetLastError(ERROR_INSUFFICIENT_BUFFER);
419	return FALSE;
420	}
421	if(lpBytesReturned) {
422	*lpBytesReturned = 0;
423	}
424	if(OSLibDosGetDiskGeometry(pHMHandleData->hHMHandle, drvInfo->driveLetter, pGeom) == FALSE) {
425	return FALSE;
426	}
427	if(lpBytesReturned) {
428	*lpBytesReturned = sizeof(DISK_GEOMETRY);
429	}
430	SetLastError(ERROR_SUCCESS);
431	return TRUE;
432	}
433
434	case IOCTL_DISK_GET_PARTITION_INFO:
435	case IOCTL_DISK_LOAD_MEDIA:
436	case IOCTL_DISK_MEDIA_REMOVAL:
437	case IOCTL_DISK_PERFORMANCE:
438	case IOCTL_DISK_REASSIGN_BLOCKS:
439	case IOCTL_DISK_SET_DRIVE_LAYOUT:
440	case IOCTL_DISK_SET_PARTITION_INFO:
441	case IOCTL_DISK_VERIFY:
442	case IOCTL_SERIAL_LSRMST_INSERT:
443	break;
444
445	case IOCTL_CDROM_UNLOAD_DRIVER:
446	case IOCTL_CDROM_READ_TOC:
447	case IOCTL_CDROM_GET_CONTROL:
448	case IOCTL_CDROM_PLAY_AUDIO_MSF:
449	case IOCTL_CDROM_SEEK_AUDIO_MSF:
450	case IOCTL_CDROM_STOP_AUDIO:
451	case IOCTL_CDROM_PAUSE_AUDIO:
452	case IOCTL_CDROM_RESUME_AUDIO:
453	break;
454
455	case IOCTL_CDROM_GET_VOLUME:
456	{
457	PVOLUME_CONTROL pVol = (PVOLUME_CONTROL)lpOutBuffer;
458	char volbuf[8];
459	DWORD parsize, datasize, ret;
460
461	if(nOutBufferSize < sizeof(VOLUME_CONTROL) \|\| !pVol) {
462	SetLastError(ERROR_INSUFFICIENT_BUFFER);
463	return FALSE;
464	}
465	if(lpBytesReturned) {
466	*lpBytesReturned = 0;
467	}
468	parsize = 4;
469	datasize = 8;
470	ret = OSLibDosDevIOCtl(pHMHandleData->hHMHandle, 0x81, 0x60, "CD01", 4, &parsize,
471	volbuf, 8, &datasize);
472
473	if(ret) {
474	SetLastError(error2WinError(ret));
475	return FALSE;
476	}
477	if(lpBytesReturned) {
478	*lpBytesReturned = sizeof(VOLUME_CONTROL);
479	}
480	pVol->PortVolume[0] = volbuf[1];
481	pVol->PortVolume[1] = volbuf[3];
482	pVol->PortVolume[2] = volbuf[5];
483	pVol->PortVolume[3] = volbuf[7];
484	SetLastError(ERROR_SUCCESS);
485	return TRUE;
486	}
487
488	case IOCTL_CDROM_SET_VOLUME:
489	{
490	PVOLUME_CONTROL pVol = (PVOLUME_CONTROL)lpInBuffer;
491	char volbuf[8];
492	DWORD parsize, datasize, ret;
493
494	if(nInBufferSize < sizeof(VOLUME_CONTROL) \|\| !pVol) {
495	SetLastError(ERROR_INSUFFICIENT_BUFFER);
496	return FALSE;
497	}
498	if(lpBytesReturned) {
499	*lpBytesReturned = 0;
500	}
501	parsize = 4;
502	datasize = 8;
503	volbuf[0] = 0;
504	volbuf[1] = pVol->PortVolume[0];
505	volbuf[2] = 1;
506	volbuf[3] = pVol->PortVolume[1];
507	volbuf[4] = 2;
508	volbuf[5] = pVol->PortVolume[2];
509	volbuf[6] = 3;
510	volbuf[7] = pVol->PortVolume[3];
511	dprintf(("Set CD volume (%d,%d)(%d,%d)", pVol->PortVolume[0], pVol->PortVolume[1], pVol->PortVolume[2], pVol->PortVolume[3]));
512	ret = OSLibDosDevIOCtl(pHMHandleData->hHMHandle, 0x81, 0x40, "CD01", 4, &parsize,
513	volbuf, 8, &datasize);
514
515	if(ret) {
516	SetLastError(error2WinError(ret));
517	return FALSE;
518	}
519	SetLastError(ERROR_SUCCESS);
520	return TRUE;
521	}
522	case IOCTL_CDROM_READ_Q_CHANNEL:
523	case IOCTL_CDROM_GET_LAST_SESSION:
524	case IOCTL_CDROM_RAW_READ:
525	case IOCTL_CDROM_DISK_TYPE:
526	case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
527	case IOCTL_CDROM_CHECK_VERIFY:
528	case IOCTL_CDROM_MEDIA_REMOVAL:
529	case IOCTL_CDROM_EJECT_MEDIA:
530	case IOCTL_CDROM_LOAD_MEDIA:
531	case IOCTL_CDROM_RESERVE:
532	case IOCTL_CDROM_RELEASE:
533	case IOCTL_CDROM_FIND_NEW_DEVICES:
534	break;
535
536	case IOCTL_STORAGE_CHECK_VERIFY:
537	if(lpBytesReturned) {
538	*lpBytesReturned = 0;
539	}
540	//TODO: check if disk has been inserted or removed
541	if(pHMHandleData->hHMHandle == 0) {
542	SetLastError(ERROR_NOT_READY);
543	return FALSE;
544	}
545	SetLastError(NO_ERROR);
546	return TRUE;
547
548	case IOCTL_STORAGE_EJECT_MEDIA:
549	case IOCTL_STORAGE_GET_MEDIA_TYPES:
550	case IOCTL_STORAGE_LOAD_MEDIA:
551	case IOCTL_STORAGE_MEDIA_REMOVAL:
552	break;
553	case IOCTL_SCSI_PASS_THROUGH:
554	case IOCTL_SCSI_MINIPORT:
555	case IOCTL_SCSI_GET_INQUIRY_DATA:
556	case IOCTL_SCSI_GET_CAPABILITIES:
557	break;
558
559	case IOCTL_SCSI_PASS_THROUGH_DIRECT:
560	{
561	PSCSI_PASS_THROUGH_DIRECT pPacket = (PSCSI_PASS_THROUGH_DIRECT)lpOutBuffer;
562	SRB_ExecSCSICmd *psrb;
563
564	if(drvInfo->hInstAspi == NULL) {
565	SetLastError(ERROR_ACCESS_DENIED);
566	return FALSE;
567	}
568
569	if(nOutBufferSize < sizeof(SCSI_PASS_THROUGH_DIRECT) \|\|
570	!pPacket \|\| pPacket->Length < sizeof(SCSI_PASS_THROUGH_DIRECT))
571	{
572	SetLastError(ERROR_INSUFFICIENT_BUFFER);
573	return FALSE;
574	}
575	if(lpBytesReturned) {
576	*lpBytesReturned = 0;
577	}
578	psrb = (SRB_ExecSCSICmd *)alloca(sizeof(SRB_ExecSCSICmd)+pPacket->SenseInfoLength);
579	if(psrb == NULL) {
580	dprintf(("not enough memory!!"));
581	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
582	return FALSE;
583	}
584	memset(psrb, 0, sizeof(*psrb));
585	psrb->SRB_Cmd = SC_EXEC_SCSI_CMD;
586	psrb->SRB_Status = pPacket->ScsiStatus;
587	psrb->SRB_HaId = pPacket->PathId;
588	psrb->SRB_Target = pPacket->TargetId;
589	psrb->SRB_Lun = pPacket->Lun;
590	psrb->SRB_BufLen = pPacket->DataTransferLength;
591	psrb->SRB_SenseLen = pPacket->SenseInfoLength;
592	psrb->SRB_CDBLen = pPacket->CdbLength;
593	switch(pPacket->DataIn) {
594	case SCSI_IOCTL_DATA_OUT:
595	psrb->SRB_Flags = 0x2 << 3;
596	break;
597	case SCSI_IOCTL_DATA_IN:
598	psrb->SRB_Flags = 0x1 << 3;
599	break;
600	case SCSI_IOCTL_DATA_UNSPECIFIED:
601	psrb->SRB_Flags = 0x3 << 3;
602	break;
603	}
604	if(pPacket->CdbLength > 16) {
605	SetLastError(ERROR_INVALID_PARAMETER);
606	return FALSE;
607	}
608	psrb->SRB_BufPointer = (BYTE *)pPacket->DataBuffer;
609	memcpy(&psrb->CDBByte[0], &pPacket->Cdb[0], 16);
610	if(psrb->SRB_SenseLen) {
611	memcpy(&psrb->SenseArea[0], (char *)pPacket + pPacket->SenseInfoOffset, psrb->SRB_SenseLen);
612	}
613	//TODO: pPacket->TimeOutValue ignored
614	int rc = drvInfo->SendASPI32Command((LPSRB)psrb);
615	if(rc != SS_COMP) {
616	dprintf(("SendASPI32Command failed with error %d", rc));
617	if(rc == SS_ERR) {
618	SetLastError(ERROR_ADAP_HDW_ERR); //returned by NT4, SP6
619	}
620	else SetLastError(ERROR_GEN_FAILURE);
621	return FALSE;
622	}
623	pPacket->ScsiStatus = rc;
624	if(lpBytesReturned) {
625	*lpBytesReturned = 0;
626	}
627	pPacket->DataTransferLength = psrb->SRB_BufLen;
628	if(psrb->SRB_SenseLen) {
629	memcpy((char *)pPacket + pPacket->SenseInfoOffset, &psrb->SenseArea[0], psrb->SRB_SenseLen);
630	}
631	SetLastError(ERROR_SUCCESS);
632	return TRUE;
633	}
634	case IOCTL_SCSI_GET_ADDRESS:
635	{
636	DWORD numAdapters, rc;
637	SRB srb;
638	int i, j, k;
639
640	if(!lpOutBuffer \|\| nOutBufferSize < 8) {
641	SetLastError(ERROR_INSUFFICIENT_BUFFER); //todo: right error?
642	return(FALSE);
643	}
644	SCSI_ADDRESS addr = (SCSI_ADDRESS )lpOutBuffer;
645	addr->Length = sizeof(SCSI_ADDRESS);
646	addr->PortNumber = 0;
647	addr->PathId = 0;
648	numAdapters = drvInfo->GetASPI32SupportInfo();
649	if(LOBYTE(numAdapters) == 0) goto failure;
650
651	memset(&srb, 0, sizeof(srb));
652	srb.common.SRB_Cmd = SC_HA_INQUIRY;
653	rc = drvInfo->SendASPI32Command(&srb);
654
655	char drivename[3];
656	drivename[0] = (char)drvInfo->driveLetter;
657	drivename[1] = ':';
658	drivename[2] = 0;
659
660	for(i=0;i<LOBYTE(numAdapters);i++) {
661	for(j=0;j<8;j++) {
662	for(k=0;k<16;k++) {
663	memset(&srb, 0, sizeof(srb));
664	srb.common.SRB_Cmd = SC_GET_DEV_TYPE;
665	srb.devtype.SRB_HaId = i;
666	srb.devtype.SRB_Target = j;
667	srb.devtype.SRB_Lun = k;
668	rc = drvInfo->SendASPI32Command(&srb);
669	if(rc == SS_COMP) {
670	if(srb.devtype.SRB_DeviceType == SS_DEVTYPE_CDROM &&
671	GetDriveTypeA(drivename) == DRIVE_CDROM)
672	{
673	goto done;
674	}
675	}
676	}
677	}
678	}
679	done:
680	if(rc == SS_COMP) {
681	addr->TargetId = j;
682	addr->Lun = k;
683	SetLastError(ERROR_SUCCESS);
684	}
685	else SetLastError(ERROR_FILE_NOT_FOUND); //todo
686	return TRUE;
687	failure:
688	SetLastError(ERROR_INVALID_PARAMETER); //todo
689	return FALSE;
690	}
691
692	case IOCTL_SCSI_RESCAN_BUS:
693	case IOCTL_SCSI_GET_DUMP_POINTERS:
694	case IOCTL_SCSI_FREE_DUMP_POINTERS:
695	case IOCTL_IDE_PASS_THROUGH:
696	break;
697
698	}
699	dprintf(("HMDeviceDiskClass::DeviceIoControl: unimplemented dwIoControlCode=%08lx\n", dwIoControlCode));
700	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
701	return FALSE;
702	}
703	/*****************************************************************************
704	* Name : BOOL HMDeviceDiskClass::ReadFile
705	* Purpose : read data from handle / device
706	* Parameters: PHMHANDLEDATA pHMHandleData,
707	* LPCVOID lpBuffer,
708	* DWORD nNumberOfBytesToRead,
709	* LPDWORD lpNumberOfBytesRead,
710	* LPOVERLAPPED lpOverlapped
711	* Variables :
712	* Result : Boolean
713	* Remark :
714	* Status :
715	*
716	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
717	*****************************************************************************/
718
719	BOOL HMDeviceDiskClass::ReadFile(PHMHANDLEDATA pHMHandleData,
720	LPCVOID lpBuffer,
721	DWORD nNumberOfBytesToRead,
722	LPDWORD lpNumberOfBytesRead,
723	LPOVERLAPPED lpOverlapped)
724	{
725	LPVOID lpRealBuf;
726	Win32MemMap *map;
727	DWORD offset, bytesread;
728	BOOL bRC;
729
730	dprintf2(("KERNEL32: HMDeviceDiskClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
731	lpHMDeviceName,
732	pHMHandleData,
733	lpBuffer,
734	nNumberOfBytesToRead,
735	lpNumberOfBytesRead,
736	lpOverlapped));
737
738	//SvL: It's legal for this pointer to be NULL
739	if(lpNumberOfBytesRead)
740	*lpNumberOfBytesRead = 0;
741	else
742	lpNumberOfBytesRead = &bytesread;
743
744	if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
745	dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
746	SetLastError(ERROR_INVALID_PARAMETER);
747	return FALSE;
748	}
749	if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
750	dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
751	}
752
753	//SvL: DosRead doesn't like writing to memory addresses returned by
754	// DosAliasMem -> search for original memory mapped pointer and use
755	// that one + commit pages if not already present
756	map = Win32MemMapView::findMapByView((ULONG)lpBuffer, &offset, MEMMAP_ACCESS_WRITE);
757	if(map) {
758	lpRealBuf = (LPVOID)((ULONG)map->getMappingAddr() + offset);
759	DWORD nrpages = nNumberOfBytesToRead/4096;
760	if(offset & 0xfff)
761	nrpages++;
762	if(nNumberOfBytesToRead & 0xfff)
763	nrpages++;
764
765	map->commitPage(offset & ~0xfff, TRUE, nrpages);
766	}
767	else lpRealBuf = (LPVOID)lpBuffer;
768
769	if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) {
770	dprintf(("ERROR: Overlapped IO not yet implememented!!"));
771	}
772	// else {
773	bRC = OSLibDosRead(pHMHandleData->hHMHandle,
774	(PVOID)lpRealBuf,
775	nNumberOfBytesToRead,
776	lpNumberOfBytesRead);
777	// }
778
779	if(bRC == 0) {
780	dprintf(("KERNEL32: HMDeviceDiskClass::ReadFile returned %08xh %x", bRC, GetLastError()));
781	dprintf(("%x -> %d", lpBuffer, IsBadWritePtr((LPVOID)lpBuffer, nNumberOfBytesToRead)));
782	}
783
784	return bRC;
785	}
786	/*****************************************************************************
787	* Name : DWORD HMDeviceDiskClass::SetFilePointer
788	* Purpose : set file pointer
789	* Parameters: PHMHANDLEDATA pHMHandleData
790	* LONG lDistanceToMove
791	* PLONG lpDistanceToMoveHigh
792	* DWORD dwMoveMethod
793	* Variables :
794	* Result : API returncode
795	* Remark :
796	* Status :
797	*
798	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
799	*****************************************************************************/
800
801	DWORD HMDeviceDiskClass::SetFilePointer(PHMHANDLEDATA pHMHandleData,
802	LONG lDistanceToMove,
803	PLONG lpDistanceToMoveHigh,
804	DWORD dwMoveMethod)
805	{
806	DWORD ret;
807
808	dprintf2(("KERNEL32: HMDeviceDiskClass::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
809	lpHMDeviceName,
810	pHMHandleData,
811	lDistanceToMove,
812	lpDistanceToMoveHigh,
813	dwMoveMethod));
814
815	ret = OSLibDosSetFilePointer(pHMHandleData->hHMHandle,
816	lDistanceToMove,
817	(DWORD *)lpDistanceToMoveHigh,
818	dwMoveMethod);
819
820	if(ret == -1) {
821	dprintf(("SetFilePointer failed (error = %d)", GetLastError()));
822	}
823	return ret;
824	}
825	//******************************************************************************
826	//******************************************************************************

Note: See TracBrowser for help on using the repository browser.

Download in other formats: