////----------------------------------------------
// File : GetHardSoftInfo.cpp
//
// Content : for displaying the details of hard drives in 
//
// Author : 06/11/2000  Lynn McGuire  written with many contributions from others,
//                            IDE drives only under Windows NT/2K and 9X,
//                            maybe SCSI drives later
//
// Fix Bug : 06/06/2003 NieHuawen(nie173@sohu.com)
//
// Content : Replant to Class
//
//-------------------------------------------------
#include "stdafx.h"
#include "GetHardSoftInfo.h"
#include "Md5A.h"
 
using namespace SoftEncrypt;

CGetMachineInfo *CGetMachineInfo::g_pMachineInfo = NULL;

typedef struct _UNICODE_STRING {
  USHORT  Length;//长度
  USHORT  MaximumLength;//最大长度
  PWSTR  Buffer;//缓存指针，访问物理内存时，此处指向UNICODE字符串"\device\physicalmemory"
} UNICODE_STRING,*PUNICODE_STRING;


typedef struct _OBJECT_ATTRIBUTES {
    ULONG Length;//长度 18h
    HANDLE RootDirectory;//  00000000
    PUNICODE_STRING ObjectName;//指向对象名的指针
    ULONG Attributes;//对象属性00000040h
    PVOID SecurityDescriptor;        // Points to type SECURITY_DESCRIPTOR，0
    PVOID SecurityQualityOfService;  // Points to type SECURITY_QUALITY_OF_SERVICE，0
} OBJECT_ATTRIBUTES;
typedef OBJECT_ATTRIBUTES *POBJECT_ATTRIBUTES;

typedef DWORD  (__stdcall *ZWOS)(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES);
typedef DWORD  (__stdcall *ZWMV)(HANDLE,HANDLE,PVOID,ULONG,ULONG,PLARGE_INTEGER,PSIZE_T,DWORD,ULONG,ULONG);
typedef DWORD  (__stdcall *ZWUMV)(HANDLE,PVOID);

CGetMachineInfo::CGetMachineInfo(void)
{
	ReadPhysicalDriveInNT();
	ReadCpuInformation ();

	//CMd5A md5;
	CString strTrueInfo = str_DN_Serial;//str_CUPNumber + 
	//str_HardInformation = md5.MDStringW ( strTrueInfo );
}

CGetMachineInfo * CGetMachineInfo::GetMachineInfo ()
{
	if (!g_pMachineInfo)
		g_pMachineInfo = new CGetMachineInfo();

	return g_pMachineInfo;
}

void CGetMachineInfo::FreeMachineInfo ()
{
	if (g_pMachineInfo)
	{
		delete g_pMachineInfo;
		g_pMachineInfo = NULL;
	}
}

BOOL CGetMachineInfo::ReturnInfo(int drive, DWORD diskdata [256])
{
	char string1 [1024];
	__int64 sectors = 0;
	__int64 bytes = 0;

	//  copy the hard drive serial number to the buffer
	strcpy (string1, ConvertToString (diskdata, 10, 19));
	if (0 == HardDriveSerialNumber [0] && (isalnum (string1 [0]) || isalnum (string1 [19])))
            //  serial number must be alphanumeric
            //  (but there can be leading spaces on IBM drives)			
			strcpy (HardDriveSerialNumber, string1);

	//#ifdef PRINTING_TO_CONSOLE_ALLOWED

	switch (drive / 2)
	{
	case 0: 
		str_HardDesk_Form ="Primary Controller";
		break;
	case 1: 
		str_HardDesk_Form ="Secondary Controller";
		break;
	case 2: 
		str_HardDesk_Form ="Tertiary Controller";
		break;
	case 3:
		str_HardDesk_Form ="Quaternary Controller";
		break;
	}

	//MessageBox(NULL,str_HardDesk_Form,NULL,NULL);
	switch (drive % 2)
	{
	case 0: 
		str_Controller ="Master drive";
		break;
	case 1:
		str_Controller ="Slave drive";
		break;
	}

	str_DN_Modol =CString(ConvertToString (diskdata, 27, 46));

	str_DN_Serial =CString(ConvertToString (diskdata, 10, 19));

	str_DN_ControllerRevision =CString(ConvertToString (diskdata, 23, 26));

	str_HardDeskBufferSize.Format(_T("%u"), diskdata [21] * 512);

	printf ("Drive Type________________________: ");
    
	if (diskdata [0] & 0x0080)
		str_HardDeskType ="Removable";
	else if (diskdata [0] & 0x0040)
		str_HardDeskType ="Fixed";
	else 
		str_HardDeskType ="Unknown";
           
	//  calculate size based on 28 bit or 48 bit addressing
	//  48 bit addressing is reflected by bit 10 of word 83
	if (diskdata [83] & 0x400) 
		sectors = diskdata [103] * 65536I64 * 65536I64 * 65536I64 + diskdata [102] * 65536I64 * 65536I64 + diskdata [101] * 65536I64 + diskdata [100];
	else
		sectors = diskdata [61] * 65536 + diskdata [60];

	//  there are 512 bytes in a sector
	bytes = sectors * 512;
	str_HardDeskSize.Format(_T("%I64d"),bytes);

	return 1;
}
//conversion to char 
char *CGetMachineInfo::ConvertToString(DWORD diskdata [256], int firstIndex, int lastIndex)
{
	static char string [1024];
	int index = 0;
	int position = 0;

	//  each integer has two characters stored in it backwards
	for (index = firstIndex; index <= lastIndex; index++)
	{
		//  get high byte for 1st character
		string [position] = (char) (diskdata [index] / 256);
		position++;

		//  get low byte for 2nd character
		string [position] = (char) (diskdata [index] % 256);
		position++;
	}
	//  end the string 
	string [position] = '\0';

	//  cut off the trailing blanks
	for (index = position - 1; index > 0 && ' ' == string [index]; index--)
		string [index] = '\0';
   
	return string;
}
//
 CGetMachineInfo::DoIDENTIFY(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
                 PSENDCMDOUTPARAMS pSCOP, BYTE bIDCmd, BYTE bDriveNum,
                 PDWORD lpcbBytesReturned)
{
	// Set up data structures for IDENTIFY command.
	pSCIP -> cBufferSize = IDENTIFY_BUFFER_SIZE;
	pSCIP -> irDriveRegs.bFeaturesReg = 0;
	pSCIP -> irDriveRegs.bSectorCountReg = 1;
	pSCIP -> irDriveRegs.bSectorNumberReg = 1;
	pSCIP -> irDriveRegs.bCylLowReg = 0;
	pSCIP -> irDriveRegs.bCylHighReg = 0;

		// Compute the drive number.
	pSCIP -> irDriveRegs.bDriveHeadReg = 0xA0 | ((bDriveNum & 1) << 4);

		// The command can either be IDE identify or ATAPI identify.
	pSCIP -> irDriveRegs.bCommandReg = bIDCmd;
	pSCIP -> bDriveNumber = bDriveNum;
	pSCIP -> cBufferSize = IDENTIFY_BUFFER_SIZE;

	return( DeviceIoControl (hPhysicalDriveIOCTL, DFP_RECEIVE_DRIVE_DATA,
               (LPVOID) pSCIP,
               sizeof(SENDCMDINPARAMS) - 1,
               (LPVOID) pSCOP,
               sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
               lpcbBytesReturned, NULL) );
}
//
int CGetMachineInfo::ReadPhysicalDriveInNT(void)
{
	int done = FALSE;
   int drive = 0;

   for (drive = 0; drive < MAX_IDE_DRIVES; drive++)
   {
      HANDLE hPhysicalDriveIOCTL = 0;

         //  Try to get a handle to PhysicalDrive IOCTL, report failure
         //  and exit if can't.
      //char driveName [256];

      //sprintf (driveName, "\\\\.\\PhysicalDrive%d", drive);
	  CString driveName;
	  driveName.Format (_T("\\\\.\\PhysicalDrive%d"), drive);

         //  Windows NT, Windows 2000, must have admin rights
      hPhysicalDriveIOCTL = CreateFile (driveName,
                               GENERIC_READ | GENERIC_WRITE, 
                               FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                               OPEN_EXISTING, 0, NULL);
      // if (hPhysicalDriveIOCTL == INVALID_HANDLE_VALUE)
      //    printf ("Unable to open physical drive %d, error code: 0x%lX\n",
      //            drive, GetLastError ());

      if (hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
	  {
		  GETVERSIONOUTPARAMS VersionParams;
		  DWORD               cbBytesReturned = 0;
		  
		  // Get the version, etc of PhysicalDrive IOCTL
		  memset ((void*) &VersionParams, 0, sizeof(VersionParams));

		  if ( ! DeviceIoControl (hPhysicalDriveIOCTL, DFP_GET_VERSION,
									NULL, 
									0,
									&VersionParams,
									sizeof(VersionParams),
									&cbBytesReturned, NULL) )
		  {         
			// printf ("DFP_GET_VERSION failed for drive %d\n", i);
			// continue;
		  }

            // If there is a IDE device at number "i" issue commands
            // to the device
         if (VersionParams.bIDEDeviceMap > 0)
         {
            BYTE             bIDCmd = 0;   // IDE or ATAPI IDENTIFY cmd
            SENDCMDINPARAMS  scip;
            //SENDCMDOUTPARAMS OutCmd;
			BYTE IdOutCmd [sizeof (SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
			// Now, get the ID sector for all IDE devices in the system.
               // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
               // otherwise use the IDE_ATA_IDENTIFY command
            bIDCmd = (VersionParams.bIDEDeviceMap >> drive & 0x10) ? \
                      IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;

            memset (&scip, 0, sizeof(scip));
            memset (IdOutCmd, 0, sizeof(IdOutCmd));

            if ( DoIDENTIFY (hPhysicalDriveIOCTL, 
                       &scip, 
                       (PSENDCMDOUTPARAMS)&IdOutCmd, 
                       (BYTE) bIDCmd,
                       (BYTE) drive,
                       &cbBytesReturned))
            {
               DWORD diskdata [256];
               int ijk = 0;
               USHORT *pIdSector = (USHORT *)
                             ((PSENDCMDOUTPARAMS) IdOutCmd) -> bBuffer;

               for (ijk = 0; ijk < 256; ijk++)
                  diskdata [ijk] = pIdSector [ijk];

               ReturnInfo (drive, diskdata);

               done = TRUE;
            }
	    }

         CloseHandle (hPhysicalDriveIOCTL);
      }
   }

   return done;
}
//
int CGetMachineInfo::ReadDrivePortsInWin9X(void)
{
	int done = FALSE;
   HANDLE VxDHandle = 0;
   pt_IdeDInfo pOutBufVxD = 0;
   DWORD lpBytesReturned = 0;

		//  set the thread priority high so that we get exclusive access to the disk
SetPriorityClass (GetCurrentProcess (), REALTIME_PRIORITY_CLASS);
	



      // 1. Make an output buffer for the VxD
   rt_IdeDInfo info;
   pOutBufVxD = &info;

      // *****************
      // KLUDGE WARNING!!!
      // HAVE to zero out the buffer space for the IDE information!
      // If this is NOT done then garbage could be in the memory
      // locations indicating if a disk exists or not.
   ZeroMemory (&info, sizeof(info));

      // 1. Try to load the VxD
       //  must use the short file name path to open a VXD file
   //char StartupDirectory [2048];
   //char shortFileNamePath [2048];
   //char *p = NULL;
   //char vxd [2048];
      //  get the directory that the exe was started from
   //GetModuleFileName (hInst, (LPSTR) StartupDirectory, sizeof (StartupDirectory));
      //  cut the exe name from string
   //p = &(StartupDirectory [strlen (StartupDirectory) - 1]);
   //while (p >= StartupDirectory && *p && '\\' != *p) p--;
   //*p = '\0';   
   //GetShortPathName (StartupDirectory, shortFileNamePath, 2048);
   //sprintf (vxd, "\\\\.\\%s\\IDE21201.VXD", shortFileNamePath);
   //VxDHandle = CreateFile (vxd, 0, 0, 0,
   //               0, FILE_FLAG_DELETE_ON_CLOSE, 0);   
   VxDHandle = CreateFile (_T("\\\\.\\IDE21201.VXD"), 0, 0, 0,
							0, FILE_FLAG_DELETE_ON_CLOSE, 0);

   if (VxDHandle != INVALID_HANDLE_VALUE)
   {
         // 2. Run VxD function
      DeviceIoControl (VxDHandle, m_cVxDFunctionIdesDInfo,
					0, 0, pOutBufVxD, sizeof(pt_IdeDInfo), &lpBytesReturned, 0);

         // 3. Unload VxD
      CloseHandle (VxDHandle);
   }
   else
	   MessageBox (NULL, _T("ERROR: Could not open IDE21201.VXD file"), TITLE, MB_ICONSTOP);

      // 4. Translate and store data
   unsigned long int i = 0;
   for (i=0; i<8; i++)
   {
      if((pOutBufVxD->DiskExists[i]) && (pOutBufVxD->IDEExists[i/2]))
      {
			DWORD diskinfo [256];
			for (int j = 0; j < 256; j++) 
				diskinfo [j] = pOutBufVxD -> DisksRawInfo [i * 256 + j];

            // process the information for this buffer
		   ReturnInfo (i, diskinfo);
			done = TRUE;
      }
   }

		//  reset the thread priority back to normal
   // SetThreadPriority (GetCurrentThread(), THREAD_PRIORITY_NORMAL);
   SetPriorityClass (GetCurrentProcess (), NORMAL_PRIORITY_CLASS);

   return done;
}
//
int CGetMachineInfo::ReadIdeDriveAsScsiDriveInNT(void)
{
	int done = FALSE;
   int controller = 0;

   for (controller = 0; controller < 2; controller++)
   {
      HANDLE hScsiDriveIOCTL = 0;
      //char   driveName [256];

      //   //  Try to get a handle to PhysicalDrive IOCTL, report failure
      //   //  and exit if can't.
      //sprintf (driveName, "\\\\.\\Scsi%d:", controller);
	  CString driveName;
	  driveName.Format (_T("\\\\.\\Scsi%d:"), controller);
         //  Windows NT, Windows 2000, any rights should do
      hScsiDriveIOCTL = CreateFile (driveName,
                               GENERIC_READ | GENERIC_WRITE, 
                               FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                               OPEN_EXISTING, 0, NULL);
      // if (hScsiDriveIOCTL == INVALID_HANDLE_VALUE)
      //    printf ("Unable to open SCSI controller %d, error code: 0x%lX\n",
      //            controller, GetLastError ());

      if (hScsiDriveIOCTL != INVALID_HANDLE_VALUE)
      {
         int drive = 0;

         for (drive = 0; drive < 2; drive++)
         {
            char buffer [sizeof (SRB_IO_CONTROL) + SENDIDLENGTH];
            SRB_IO_CONTROL *p = (SRB_IO_CONTROL *) buffer;
            SENDCMDINPARAMS *pin =
                   (SENDCMDINPARAMS *) (buffer + sizeof (SRB_IO_CONTROL));
            DWORD dummy;
   
            memset (buffer, 0, sizeof (buffer));
            p -> HeaderLength = sizeof (SRB_IO_CONTROL);
            p -> Timeout = 10000;
            p -> Length = SENDIDLENGTH;
            p -> ControlCode = IOCTL_SCSI_MINIPORT_IDENTIFY;
            strncpy ((char *) p -> Signature, "SCSIDISK", 8);
  
            pin -> irDriveRegs.bCommandReg = IDE_ATA_IDENTIFY;
            pin -> bDriveNumber = drive;

            if (DeviceIoControl (hScsiDriveIOCTL, IOCTL_SCSI_MINIPORT, 
                                 buffer,
                                 sizeof (SRB_IO_CONTROL) +
                                         sizeof (SENDCMDINPARAMS) - 1,
                                 buffer,
                                 sizeof (SRB_IO_CONTROL) + SENDIDLENGTH,
                                 &dummy, NULL))
            {
               SENDCMDOUTPARAMS *pOut =
                    (SENDCMDOUTPARAMS *) (buffer + sizeof (SRB_IO_CONTROL));
               IDSECTOR *pId = (IDSECTOR *) (pOut -> bBuffer);
               if (pId -> sModelNumber [0])
               {
                  DWORD diskdata [256];
                  int ijk = 0;
                  USHORT *pIdSector = (USHORT *) pId;
          
                  for (ijk = 0; ijk < 256; ijk++)
                     diskdata [ijk] = pIdSector [ijk];

                  ReturnInfo (controller * 2 + drive, diskdata);

                  done = TRUE;
               }
            }
         }
         CloseHandle (hScsiDriveIOCTL);
      }
   }

   return done;
}
//
int CGetMachineInfo::ReadCpuInformation (void)
{
	CString strComp = _T("");
	CString strResult = _T("");

	for (int i = 0; i < 100000; i++)
	{
		unsigned long s1 = 1,s2 = 1, s3 = 1, s4 = 1;
		unsigned char vendor_id[]="------------";
		__asm {
		xor eax,eax
		cpuid
		mov dword ptr vendor_id,ebx
		mov dword ptr vendor_id[+4],edx
		mov dword ptr vendor_id[+8],ecx
		mov eax,01h
		xor edx,edx
		cpuid
		mov s1,edx
		mov s2,eax
		mov s3,ebx
		mov s4,ecx
		}

		s2 += 999;

		strResult.Format (_T("%08X%08X%08X%08X"), s1,s2,s3,s4);

		int nTemp = strResult.Compare ( strComp );
		if (nTemp > 0)
			strComp = strResult;
	}

	//for (POSITION pos = map.

	str_CUPNumber = strResult;

	return 0;
}
