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

Last change on this file since 6053 was 6053, checked in by sandervl, 24 years ago

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