开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
scsipt.c
资源名称：xtractor.zip　[点击查看]
上传用户：xmgzy123
上传日期：2007-01-07
资源大小：373k
文件大小：14k
源码类别：

SCSI/ASPI

开发平台：

WINDOWS

scsipt.c：源码内容
  1. /*
  2.  * scsipt.c - Copyright (C) 1999 Jay A. Key
  3.  *
  4.  * Native NT support functions via the SCSI Pass Through interface instead
  5.  * of ASPI.  Although based on information from the NT 4.0 DDK from 
  6.  * Microsoft, the information has been sufficiently distilled to allow
  7.  * compilation w/o having the DDK installed.
  8.  *
  9.  * Implements the following functions:
  10.  *   DWORD SPTIGetASPI32SupportInfo(void);
  11.  *   DWORD SPTISendASPI32Command(LPSRB);
  12.  * which are equivalents to their ASPI counterparts.  Additionally implements
  13.  *   int InitSCSIPT( void );
  14.  *   int DeinitSCSIPT( void );
  15.  *
  16.  **********************************************************************
  17.  *
  18.  * This program is free software; you can redistribute it and/or modify
  19.  * it under the terms of the GNU Lesser General Public License as published
  20.  * by the Free Software Foundation; either version 2 of the License, or
  21.  * (at your option) any later version.
  22.  *
  23.  * This program is distributed in the hope that it will be useful,
  24.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26.  * GNU General Public License for more details.
  27.  *
  28.  * You should have received a copy of the GNU Lesser General Public License
  29.  * along with this program; if not, write to the Free Software
  30.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  31.  *
  32.  **********************************************************************
  33.  *
  34.  * $Id: scsipt.c,v 1.2 2000/02/25 10:47:37 akey Exp $
  35.  * $Date: &
  36.  * $Locker:  $
  37.  * $Log: scsipt.c,v $
  38.  * Revision 1.2  2000/02/25 10:47:37  akey
  39.  * sync'ed with akrip32.dll v0.94
  40.  *
  41.  * Revision 1.6  2000/02/25 10:13:26  akey
  42.  * Added SPTIOpenCDHandle for scsi pass through
  43.  *
  44.  * Revision 1.5  2000/02/25 07:50:38  akey
  45.  * CreateFile now tries both with/without the GENERIC_WRITE flag
  46.  *
  47.  * Revision 1.4  2000/02/14 09:56:25  akey
  48.  * cleaned up #ifdef _DEBUG code considerably
  49.  *
  50.  * Revision 1.3  2000/01/31 15:35:40  akey
  51.  * v0.93: added CDDBGetServerList and fixed problem with Win2000 scsi pass through code
  52.  *
  53.  * Revision 1.2  2000/01/17 11:11:29  akey
  54.  * Put debug code in #ifdef
  55.  *
  56.  * Revision 1.1  2000/01/12 10:06:05  akey
  57.  * Minimal SCSI passthrough IOCTL support
  58.  *
  59.  *
  60.  */
  62. #include <windows.h>
  63. #include <stdio.h>
  64. #include <stddef.h>
  65. #include "myaspi32.h"
  66. #include "scsidefs.h"
  67. #include "aspilib.h"
  68. #include "akrip32.h"
  69. #include "scsipt.h"
  72. typedef struct {
  73.   BYTE ha;
  74.   BYTE tgt;
  75.   BYTE lun;
  76.   BYTE driveLetter;
  77.   BOOL bUsed;
  78.   HANDLE hDevice;
  79.   BYTE inqData[36];
  80. } DRIVE;
  82. typedef struct {
  83.   BYTE numAdapters;
  84.   DRIVE drive[26];
  85. } SPTIGLOBAL;
  87. void GetDriveInformation( BYTE i, DRIVE *pDrive );
  88. BYTE SPTIGetNumAdapters( void );
  89. BYTE SPTIGetDeviceIndex( BYTE ha, BYTE tgt, BYTE lun );
  90. DWORD SPTIHandleHaInquiry( LPSRB_HAInquiry lpsrb );
  91. DWORD SPTIGetDeviceType( LPSRB_GDEVBlock lpsrb );
  92. DWORD SPTIExecSCSICommand( LPSRB_ExecSCSICmd lpsrb, BOOL bBeenHereBefore );
  93. HANDLE GetFileHandle( BYTE i );
  95. static BOOL bSCSIPTInit = FALSE;
  96. static SPTIGLOBAL sptiglobal;
  97. static BOOL bUsingSCSIPT = FALSE;
  99. /*
  100.  * Initialization of SCSI Pass Through Interface code.  Responsible for
  101.  * setting up the array of SCSI devices.  This code will be a little
  102.  * different from the normal code -- it will query each drive letter from
  103.  * C: through Z: to see if it is  a CD.  When we identify a CD, we then 
  104.  * send CDB with the INQUIRY command to it -- NT will automagically fill in
  105.  * the PathId, TargetId, and Lun for us.
  106.  */
  107. int InitSCSIPT( void )
  108. {
  109.   BYTE i;
  110.   char buf[4];
  111.   UINT uDriveType;
  112.   int retVal = 0;
  114.   if ( bSCSIPTInit )
  115.     return 0;
  117.   ZeroMemory( &sptiglobal, sizeof(SPTIGLOBAL) );
  118.   for( i = 0; i < 26; i++ )
  119.     sptiglobal.drive[i].hDevice = INVALID_HANDLE_VALUE;
  120.   for( i = 2; i < 26; i++ )
  121.     {
  122.       wsprintf( buf, "%c:\", (char)('A'+i) );
  123.       uDriveType = GetDriveType( buf );
  124.       if ( uDriveType == DRIVE_CDROM )
  125. {
  126.   GetDriveInformation( i, &sptiglobal.drive[i] );
  127.   if ( sptiglobal.drive[i].bUsed )
  128.     retVal++;
  129. }
  130.     }
  132.   sptiglobal.numAdapters = SPTIGetNumAdapters( );
  134.   bSCSIPTInit = TRUE;
  135.   if ( retVal > 0 )
  136.     bUsingSCSIPT = TRUE;
  137.   return retVal;
  138. }
  141. int DeinitSCSIPT( void )
  142. {
  143.   BYTE i;
  145.   if ( !bSCSIPTInit )
  146.     return 0;
  148.   for( i = 2; i < 26; i++ )
  149.     {
  150.       if ( sptiglobal.drive[i].bUsed )
  151. {
  152.   CloseHandle( sptiglobal.drive[i].hDevice );
  153. }
  154.     }
  156.   sptiglobal.numAdapters = SPTIGetNumAdapters( );
  158.   ZeroMemory( &sptiglobal, sizeof(SPTIGLOBAL) );
  159.   bSCSIPTInit = TRUE;
  160.   return -1;
  161. }
  165. BYTE SPTIGetNumAdapters( void )
  166. {
  167.   BYTE buf[256];
  168.   WORD i;
  169.   BYTE numAdapters = 0;
  171.   ZeroMemory( buf, 256 );
  173.   for( i = 0; i < 26; i++ )
  174.     {
  175.       if ( sptiglobal.drive[i].bUsed )
  176. buf[sptiglobal.drive[i].ha] = 1;
  177.     }
  179.   for( i = 0; i <= 255; i++ )
  180.     if ( buf[i] )
  181.       numAdapters++;
  183.   return numAdapters;
  184. }
  187. DWORD SPTIGetASPI32SupportInfo( void )
  188. {
  189.   DWORD retVal;
  191. #ifdef _DEBUG_SCSIPT
  192.   dbprintf( "AKRip32: SPTIGetASPI32SupportInfo" );
  193. #endif
  194.   if ( !sptiglobal.numAdapters )
  195.     retVal = (DWORD)(MAKEWORD(0,SS_NO_ADAPTERS));
  196.   else
  197.     retVal = (DWORD)(MAKEWORD(sptiglobal.numAdapters,SS_COMP));
  199.   return retVal;
  200. }
  202. /*
  203.  * Needs to call the appropriate function for the lpsrb->SRB_Cmd specified.
  204.  * Valid types are SC_HA_INQUIRY, SC_GET_DEV_TYPE, SC_EXEC_SCSI_CMD,
  205.  * and SC_RESET_DEV.
  206.  */
  207. DWORD SPTISendASPI32Command( LPSRB lpsrb )
  208. {
  209.   if ( !lpsrb )
  210.     return SS_ERR;
  212.   switch( lpsrb->SRB_Cmd )
  213.     {
  214.     case SC_HA_INQUIRY:
  215.       return SPTIHandleHaInquiry( (LPSRB_HAInquiry)lpsrb );
  217.     case SC_GET_DEV_TYPE:
  218.       return SPTIGetDeviceType( (LPSRB_GDEVBlock)lpsrb );
  220.     case SC_EXEC_SCSI_CMD:
  221.       return SPTIExecSCSICommand( (LPSRB_ExecSCSICmd)lpsrb, FALSE );
  223.     case SC_RESET_DEV:
  224.     default:
  225.       lpsrb->SRB_Status = SS_ERR;
  226.       return SS_ERR;
  227.     }
  229.   return SS_ERR;  // should never get to here...
  230. }
  233. /*
  234.  * Universal function to get a file handle to the CD device.  Since
  235.  * NT 4.0 wants just the GENERIC_READ flag, and Win2K wants both
  236.  * GENERIC_READ and GENERIC_WRITE (why a read-only CD device needs
  237.  * GENERIC_WRITE access is beyond me...), the easist workaround is to just
  238.  * try them both.
  239.  */
  240. HANDLE GetFileHandle( BYTE i )
  241. {
  242.   char buf[12];
  243.   HANDLE fh;
  244.   OSVERSIONINFO osver;
  245.   DWORD dwFlags;
  247.   ZeroMemory( &osver, sizeof(osver) );
  248.   osver.dwOSVersionInfoSize = sizeof(osver);
  249.   GetVersionEx( &osver );
  251.   // if Win2K or greater, add GENERIC_WRITE
  252.   dwFlags = GENERIC_READ;
  253.   if ( (osver.dwPlatformId == VER_PLATFORM_WIN32_NT) &&
  254.        (osver.dwMajorVersion > 4) )
  255.     {
  256.       dwFlags |= GENERIC_WRITE;
  257. #ifdef _DEBUG_SCSIPT
  258.       dbprintf( "AKRip32: SCSIPT: GetFileHandle(): Setting for Win2K" );
  259. #endif
  260.     }
  262.   wsprintf( buf, "\\.\%c:", (char)('A'+i) );
  263.   fh = CreateFile( buf, dwFlags, FILE_SHARE_READ, NULL,
  264.    OPEN_EXISTING, 0, NULL );
  266.   if ( fh == INVALID_HANDLE_VALUE )
  267.     {
  268.       dwFlags ^= GENERIC_WRITE;
  269.       fh = CreateFile( buf, dwFlags, FILE_SHARE_READ, NULL,
  270.        OPEN_EXISTING, 0, NULL );
  271.     }
  274. #ifdef _DEBUG_SCSIPT
  275.   dbprintf( "akrip32: scsipt: CreateFile() failed! -> %d", GetLastError() );
  276. #endif
  278.   return fh;
  279. }
  283. void GetDriveInformation( BYTE i, DRIVE *pDrive )
  284. {
  285.   HANDLE fh;
  286.   //char buf[12];
  287.   BOOLEAN status;
  288.   SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER swb;
  289.   ULONG length, returned;
  290.   BYTE inqData[100];
  292. #ifdef _DEBUG_SCSIPT
  293.   dbprintf( "AKRip32: SCSIPT: Checking drive %c:", 'A'+i );
  294. #endif
  296.   fh = GetFileHandle( i );
  298.   if ( fh == INVALID_HANDLE_VALUE )
  299.     {
  300. #ifdef _DEBUG_SCSIPT
  301.       dbprintf( "       : fh == INVALID_HANDLE_VALUE" );
  302. #endif
  303.       return;
  304.     }
  306. #ifdef _DEBUG_SCSIPT
  307.   dbprintf( "       : Index %d: fh == %08X", i, fh );
  308. #endif
  310.   ZeroMemory( &swb, sizeof(swb) );
  311.   ZeroMemory( inqData, 100 );
  313.   swb.spt.Length          = sizeof(SCSI_PASS_THROUGH);
  314.   swb.spt.CdbLength       = 6;
  315.   swb.spt.SenseInfoLength = 24;
  316.   swb.spt.DataIn          = SCSI_IOCTL_DATA_IN;
  317.   swb.spt.DataTransferLength = 100;
  318.   swb.spt.TimeOutValue    = 2;
  319.   swb.spt.DataBuffer      = inqData;
  320.   swb.spt.SenseInfoOffset = offsetof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER,ucSenseBuf );
  321.   swb.spt.Cdb[0]          = 0x12;
  322.   swb.spt.Cdb[4]          = 100;
  324.   length = sizeof(swb);
  325. #ifdef _DEBUG_SCSIPT
  326.   dbprintf( "AKRip32: GetDriveInformation: Calling DeviceIoControl" );
  327. #endif
  328.   status = DeviceIoControl( fh,
  329.     IOCTL_SCSI_PASS_THROUGH_DIRECT,
  330.     &swb,
  331.     length,
  332.     &swb,
  333.     length,
  334.     &returned,
  335.     NULL );
  337.   if ( !status )
  338.     {
  339.       CloseHandle( fh );
  340. #ifdef _DEBUG_SCSIPT
  341.       dbprintf( "AKRip32: SCSIPT: Error DeviceIoControl() -> %d",
  342. GetLastError() );
  343. #endif
  344.       return;
  345.     }
  347. #ifdef _DEBUG_SCSIPT
  348.   dbprintf( "AKRip32: SPTI: Adding drive %c: (%d:%d:%d)", 'A'+i,
  349.     swb.spt.PathId, swb.spt.TargetId, swb.spt.Lun );
  350. #endif
  351.   pDrive->bUsed     = TRUE;
  352.   pDrive->ha        = swb.spt.PathId;
  353.   pDrive->tgt       = swb.spt.TargetId;
  354.   pDrive->lun       = swb.spt.Lun;
  355.   pDrive->driveLetter = i;
  356.   pDrive->hDevice   = INVALID_HANDLE_VALUE;
  357.   memcpy( pDrive->inqData, inqData, 36 );
  359.   CloseHandle( fh );
  360. }
  364. DWORD SPTIHandleHaInquiry( LPSRB_HAInquiry lpsrb )
  365. {
  366.   DWORD *pMTL;
  368.   lpsrb->HA_Count    = sptiglobal.numAdapters;
  369.   if ( lpsrb->SRB_HaID >= sptiglobal.numAdapters )
  370.     {
  371.       lpsrb->SRB_Status = SS_INVALID_HA;
  372.       return SS_INVALID_HA;
  373.     }
  374.   lpsrb->HA_SCSI_ID  = 7;  // who cares... we're not really an ASPI manager
  375.   memcpy( lpsrb->HA_ManagerId,  "AKASPI v0.000001", 16 );
  376.   memcpy( lpsrb->HA_Identifier, "SCSI Adapter    ", 16 );
  377.   lpsrb->HA_Identifier[13] = (char)('0'+lpsrb->SRB_HaID);
  378.   ZeroMemory( lpsrb->HA_Unique, 16 );
  379.   lpsrb->HA_Unique[3] = 8;
  380.   pMTL = (LPDWORD)&lpsrb->HA_Unique[4];
  381.   *pMTL = 64 * 1024;
  383.   lpsrb->SRB_Status = SS_COMP;
  384.   return SS_COMP;
  385. }
  388. /*
  389.  * Scans through the drive array and returns DTYPE_CDROM type for all items
  390.  * found, and DTYPE_UNKNOWN for all others.
  391.  */
  392. DWORD SPTIGetDeviceType( LPSRB_GDEVBlock lpsrb )
  393. {
  394. #ifdef _DEBUG_SCSIPT
  395.   dbprintf( "AKRip32: SPTIGetDeviceType( %d:%d:%d )",lpsrb->SRB_HaID, lpsrb->SRB_Target, lpsrb->SRB_Lun );
  396. #endif
  398.   lpsrb->SRB_Status = SS_NO_DEVICE;
  399.   if ( SPTIGetDeviceIndex( lpsrb->SRB_HaID, lpsrb->SRB_Target, lpsrb->SRB_Lun ) )
  400.     lpsrb->SRB_Status = SS_COMP;
  402.   if ( lpsrb->SRB_Status == SS_COMP )
  403.     lpsrb->SRB_DeviceType = DTYPE_CDROM;
  404.   else
  405.     lpsrb->SRB_DeviceType = DTYPE_UNKNOWN;
  407.   return lpsrb->SRB_Status;
  408. }
  411. BYTE SPTIGetDeviceIndex( BYTE ha, BYTE tgt, BYTE lun )
  412. {
  413.   BYTE i;
  415. #ifdef _DEBUG_SCSIPT
  416.   dbprintf( "AKRip32: SPTIGetDeviceIndex" );
  417. #endif
  419.   for( i = 2; i < 26; i++ )
  420.     {
  421.       if ( sptiglobal.drive[i].bUsed )
  422. {
  423.   DRIVE *lpd;
  424.   lpd = &sptiglobal.drive[i];
  425.   if ( (lpd->ha == ha) && (lpd->tgt == tgt) && (lpd->lun == lun) )
  426.     return i;
  427. }
  428.     }
  430.   return 0;
  431. }
  433. /*
  434.  * Converts ASPI-style SRB to SCSI Pass Through IOCTL
  435.  */
  436. DWORD SPTIExecSCSICommand( LPSRB_ExecSCSICmd lpsrb, BOOL bBeenHereBefore )
  437. {
  438.   BOOLEAN status;
  439.   SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER swb;
  440.   ULONG length, returned;
  441.   //BYTE i;
  442.   BYTE idx;
  444.   idx = SPTIGetDeviceIndex( lpsrb->SRB_HaID, lpsrb->SRB_Target, lpsrb->SRB_Lun );
  446.   if ( idx == 0 )
  447.     {
  448.       lpsrb->SRB_Status = SS_ERR;
  449.       return SS_ERR;
  450.     }
  452.   if ( lpsrb->CDBByte[0] == 0x12 ) // is it an INQUIRY?
  453.     {
  454.       lpsrb->SRB_Status = SS_COMP;
  455.       memcpy( lpsrb->SRB_BufPointer, sptiglobal.drive[idx].inqData, 36 );
  456.       return SS_COMP;
  457.     }
  459.   if ( sptiglobal.drive[idx].hDevice == INVALID_HANDLE_VALUE )
  460.     sptiglobal.drive[idx].hDevice = GetFileHandle( sptiglobal.drive[idx].driveLetter );
  462.   ZeroMemory( &swb, sizeof(swb) );
  463.   swb.spt.Length            = sizeof(SCSI_PASS_THROUGH);
  464.   swb.spt.CdbLength         = lpsrb->SRB_CDBLen;
  465.   if ( lpsrb->SRB_Flags & SRB_DIR_IN )
  466.     swb.spt.DataIn          = SCSI_IOCTL_DATA_IN;
  467.   else if ( lpsrb->SRB_Flags & SRB_DIR_OUT )
  468.     swb.spt.DataIn          = SCSI_IOCTL_DATA_OUT;
  469.   else
  470.     swb.spt.DataIn          = SCSI_IOCTL_DATA_UNSPECIFIED;
  471.   swb.spt.DataTransferLength = lpsrb->SRB_BufLen;
  472.   swb.spt.TimeOutValue      = 5;
  473.   swb.spt.DataBuffer        = lpsrb->SRB_BufPointer;
  474.   swb.spt.SenseInfoOffset   =
  475.     offsetof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER, ucSenseBuf );
  476.   memcpy( swb.spt.Cdb, lpsrb->CDBByte, lpsrb->SRB_CDBLen );
  477.   length = sizeof(swb);
  479. #ifdef _DEBUG_SCSIPT
  480.   dbprintf( "AKRip32: SPTIExecSCSICmd: calling DeviceIoControl()" );
  481.   dbprintf( "       : cmd == 0x%02X", swb.spt.Cdb[0] );
  482. #endif
  483.   status = DeviceIoControl( sptiglobal.drive[idx].hDevice,
  484.     IOCTL_SCSI_PASS_THROUGH_DIRECT,
  485.     &swb,
  486.     length,
  487.     &swb,
  488.     length,
  489.     &returned,
  490.     NULL );
  492.   if ( status )
  493.     {
  494.       lpsrb->SRB_Status = SS_COMP;
  495.       OutputDebugString( "       : SRB_Status == SS_COMP" );
  496.     }
  497.   else
  498.     {
  499.       DWORD dwErrCode;
  501.       lpsrb->SRB_Status = SS_ERR;
  502.       lpsrb->SRB_TargStat = 0x0004;
  503.       dwErrCode = GetLastError();
  504. #ifdef _DEBUG_SCSIPT
  505.       dbprintf( "       : error == %d   handle == %08X", dwErrCode, sptiglobal.drive[idx].hDevice );
  506. #endif
  507.       /*
  508.        * KLUDGE ALERT! KLUDGE ALERT! KLUDGE ALERT!
  509.        * Whenever a disk changer switches disks, it may render the device
  510.        * handle invalid.  We try to catch these errors here and recover
  511.        * from them.
  512.        */
  513.       if ( !bBeenHereBefore &&
  514.    ((dwErrCode == ERROR_MEDIA_CHANGED) || (dwErrCode == ERROR_INVALID_HANDLE)) )
  515. {
  516.   if ( dwErrCode != ERROR_INVALID_HANDLE )
  517.     CloseHandle( sptiglobal.drive[idx].hDevice );
  518.   GetDriveInformation( idx, &sptiglobal.drive[idx] );
  519. #ifdef _DEBUG_SCSIPT
  520.   dbprintf( "AKRip32: SPTIExecSCSICommand: Retrying after ERROR_MEDIA_CHANGED" );
  521. #endif
  522.   return SPTIExecSCSICommand( lpsrb, TRUE );
  523. }
  524.     }
  526.   return lpsrb->SRB_Status;
  527. }
  531. BOOL UsingSCSIPT( void )
  532. {
  533.   return bUsingSCSIPT;
  534. }
  538. /*
  539.  * Calls GetFileHandle for the CD refered to by ha:tgt:lun to open it for
  540.  * use
  541.  */
  542. void SPTIOpenCDHandle( BYTE ha, BYTE tgt, BYTE lun )
  543. {
  544.   BYTE idx;
  546.   idx = SPTIGetDeviceIndex( ha, tgt, lun );
  548.   if ( idx && sptiglobal.drive[idx].hDevice == INVALID_HANDLE_VALUE )
  549.     sptiglobal.drive[idx].hDevice = GetFileHandle( sptiglobal.drive[idx].driveLetter );  
  550. }