FiveTech Support Forums

#pragma BEGINDUMP

#include <hbapi.h>
#include <Windows.h>

HB_FUNC( TEST )
{
   HANDLE disk0; 
   DWORD retCount, dwRet = 0; 
   // GETVERSIONINPARAMS versionInfo;
   SENDCMDINPARAMS stCIP;
   char szOutput[ 512 + 16 ]; // OUT_BUFFER_SIZE IDENTIFY_BUFFER_SIZE+16

   /* get a handle for physical disk 0 (the C: drive) */
   if ((disk0 = CreateFile (
      L"\\\\.\\PhysicalDrive0",
      GENERIC_READ, 
      NULL, 
      NULL, 
      OPEN_EXISTING, 
      FILE_ATTRIBUTE_NORMAL, 
      NULL)) == INVALID_HANDLE_VALUE) 
   {
      MessageBox( 0, "1", "Info", 0 );
      return; 
   }

    memset( szOutput, 0, sizeof( szOutput ) ); 

    #define DRIVE_HEAD_REG  0xA0

    stCIP.cBufferSize=IDENTIFY_BUFFER_SIZE;
    stCIP.bDriveNumber = 0; // ucDriveIndex;
    stCIP.irDriveRegs.bFeaturesReg= 0;
    stCIP.irDriveRegs.bSectorCountReg = 1;
    stCIP.irDriveRegs.bSectorNumberReg = 1;
    stCIP.irDriveRegs.bCylLowReg = 0;
    stCIP.irDriveRegs.bCylHighReg = 0;
    stCIP.irDriveRegs.bDriveHeadReg = DRIVE_HEAD_REG;
    stCIP.irDriveRegs.bCommandReg = ID_CMD;

    if ( DeviceIoControl( disk0, SMART_RCV_DRIVE_DATA, &stCIP, sizeof(stCIP), szOutput, 512 + 16,
         &dwRet, NULL) )
    {
       MessageBox( 0, "pasa", "ok", 0 );
    }

   MessageBox( 0, szOutput, "buffer", 0 );

/* close everything & go home */
   CloseHandle (disk0); 
   // hb_retclen( szOutput, dwRet );
}

#pragma ENDDUMP

#pragma BEGINDUMP

#include <hbapi.h>
#include <Windows.h>

HB_FUNC( TEST )
{
     char szVolumeLetter[32];
     char szPhysicalDrive[64];

     HANDLE hPhysicalDriveIOCTL = CreateFile(L"\\\\.\\PhysicalDrive0", GENERIC_READ | GENERIC_WRITE,

                FILE_SHARE_READ  | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);

     if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)

     {

                DWORD dwBytesReturned = 0;

         

                // Get Physical Drive Information

                VOLUME_DISK_EXTENTS   vdExtents;
                GETVERSIONINPARAMS  gvopVersionParams;


                ZeroMemory(&vdExtents,   sizeof(vdExtents));

                if(!DeviceIoControl(hPhysicalDriveIOCTL,   IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,  NULL, 0,

                     &vdExtents,   sizeof(vdExtents),  &dwBytesReturned, NULL)){

                     MessageBox( 0 , "Error   volumes  that span multiple disks are not supported!", "sorry", 0 );

                     CloseHandle(hPhysicalDriveIOCTL);

                     return    1;

                }



                // Get SMART version information

                ZeroMemory(&gvopVersionParams,   sizeof(gvopVersionParams));

                if(!DeviceIoControl(hPhysicalDriveIOCTL,   SMART_GET_VERSION,  NULL, 0,

                     &gvopVersionParams ,  sizeof(gvopVersionParams), &dwBytesReturned, NULL)){

                     MessageBox( 0, "Error   cannot  get SMART version information from device!", "warning", 0 );

                     CloseHandle(hPhysicalDriveIOCTL);

                return 1;

                }

        

                if(gvopVersionParams.bIDEDeviceMap > 0)

                {

                     // Setup SMART request

                     SENDCMDINPARAMS   InParams  = {

                             IDENTIFY_BUFFER_SIZE,  { 0, 1, 1, 0, 0, ((vdExtents.Extents[0].DiskNumber & 1) ? 0xB0 : 0xA0),

                             ((gvopVersionParams.bIDEDeviceMap  >> vdExtents.Extents[0].DiskNumber & 0x10) ? ATAPI_ID_CMD : ID_CMD) },

                             (BYTE)vdExtents.Extents [0].DiskNumber

                     };
 
                        

                       DWORD dwBufSize = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;

                     SENDCMDOUTPARAMS pbtIDOutCmd; //   = (PSENDCMDOUTPARAMS) new BYTE[dwBufSize];

                     ZeroMemory(&pbtIDOutCmd,  dwBufSize);

                     
 
                       // Get SMART information

                     if(DeviceIoControl (hPhysicalDriveIOCTL, SMART_RCV_DRIVE_DATA, &InParams, sizeof(SENDCMDINPARAMS),

                             &pbtIDOutCmd,  dwBufSize, &dwBytesReturned, NULL))

                     {

                           // Little Endian To Big Endian

                             USHORT  *pIDSector = (USHORT*)pbtIDOutCmd.bBuffer;
                             int nShort;
                             char lpszSerialNumber1[ 21 ];
                             LPSTR  lpszSerialNumber2;

                             for( nShort = 10; nShort < 21; nShort++)

                                   pIDSector [nShort] = (((pIDSector[nShort] & 0x00FF) << 8) + ((pIDSector[nShort] & 0xFF00) >> 8));

                            

                            // Get Drive Serial Number

                             ZeroMemory(lpszSerialNumber1, 21);

                             RtlCopyMemory(lpszSerialNumber1,  &pIDSector[10], 20);

                            

                            // Remove those horrible spaces caused because of endianess

                           // and print out the serial

                             lpszSerialNumber2 = lpszSerialNumber1;

                             while(*lpszSerialNumber2  == ' ') lpszSerialNumber2++;

                             MessageBox( 0, "Physical  Serial:", lpszSerialNumber2, 0);

                             // delete  lpszSerialNumber1;

                     }

                     // delete    pbtIDOutCmd;
 
                

                }else{
 
                     printf ("Error  !\n");

                     CloseHandle(hPhysicalDriveIOCTL);

                     return    1;

                }

                CloseHandle  (hPhysicalDriveIOCTL);
   }
}

#pragma ENDDUMP

#include "FiveWin.ch"

//----------------------------------------------------------------------------//

function Main()

   MsgInfo( SerialNumber() )

return nil

//----------------------------------------------------------------------------//

#pragma BEGINDUMP

#include <hbapi.h>
#include <Windows.h>

HB_FUNC(SERIALNUMBER)
{
    HANDLE hPhysicalDriveIOCTL = 0;

    hPhysicalDriveIOCTL = (HANDLE)CreateFile(L"\\\\.\\PhysicalDrive0", 0,
        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
        OPEN_EXISTING, 0, NULL);

    if (hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
    {
        STORAGE_PROPERTY_QUERY query;
        DWORD cbBytesReturned = 0;
        char buffer[10000];

        memset((void *)&query, 0, sizeof(query));
        query.PropertyId = StorageDeviceProperty;
        query.QueryType = PropertyStandardQuery;

        memset(buffer, 0, sizeof(buffer));

        if (DeviceIoControl(hPhysicalDriveIOCTL, IOCTL_STORAGE_QUERY_PROPERTY,
            &query,
            sizeof(query),
            &buffer,
            sizeof(buffer),
            &cbBytesReturned, NULL))
        {
            hb_retclen(buffer + 126, 20);
        }
    }
}

#pragma ENDDUMP

#include "FiveWin.ch"

//----------------------------------------------------------------------------//

function Main()

   MsgInfo( SerialNumber() )
   
return nil

//----------------------------------------------------------------------------//

#pragma BEGINDUMP

#include <hbapi.h>
#include <Windows.h>

#define IOCTL_STORAGE_QUERY_PROPERTY 0x2D1400

typedef struct _STORAGE_PROPERTY_QUERY {
  int PropertyId;
  int QueryType;
  BYTE AdditionalParameters[ 1 ];
} STORAGE_PROPERTY_QUERY, *PSTORAGE_PROPERTY_QUERY;

HB_FUNC( SERIALNUMBER )
{
    HANDLE hPhysicalDriveIOCTL = ( HANDLE ) CreateFile( "\\\\.\\PhysicalDrive0", 0,
                                   FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                                   OPEN_EXISTING, 0, NULL);

    if( hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE )
    {
        STORAGE_PROPERTY_QUERY query;
        DWORD cbBytesReturned = 0;
        char buffer[ 10000 ];

        memset( ( void * ) &query, 0, sizeof( query ) );
        query.PropertyId = 0; // StorageDeviceProperty;
        query.QueryType = 0;  // PropertyStandardQuery;

        memset( buffer, 0, sizeof( buffer ) );

        if( DeviceIoControl( hPhysicalDriveIOCTL, IOCTL_STORAGE_QUERY_PROPERTY,
              &query,
              sizeof( query ),
              &buffer,
              sizeof( buffer ),
              &cbBytesReturned, NULL ) )
        {
           hb_retclen( buffer + 126, 20 );
        }
        else
           hb_retc( "can't read it" );
    }
    else 
           hb_retc( "can't read it" );
}

#pragma ENDDUMP

#include "FiveWin.ch"

//----------------------------------------------------------------------------//

function Main()

   MsgInfo( SerialNumber() )
   
return nil

//----------------------------------------------------------------------------//

#pragma BEGINDUMP

#include <hbapi.h>
#include <Windows.h>

#define IOCTL_STORAGE_QUERY_PROPERTY 0x2D1400

typedef struct _STORAGE_PROPERTY_QUERY {
  int PropertyId;
  int QueryType;
  BYTE AdditionalParameters[ 1 ];
} STORAGE_PROPERTY_QUERY, *PSTORAGE_PROPERTY_QUERY;

HB_FUNC( SERIALNUMBER )
{
    HANDLE hPhysicalDriveIOCTL = ( HANDLE ) CreateFile( "\\\\.\\PhysicalDrive0", 0,
                                                                                     FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);

    if( hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE )
    {
        STORAGE_PROPERTY_QUERY query;
        DWORD cbBytesReturned = 0;
        char buffer[ 10000 ];

        memset( ( void * ) &query, 0, sizeof( query ) );
        query.PropertyId = 0; // StorageDeviceProperty;
        query.QueryType = 0;  // PropertyStandardQuery;

        memset( buffer, 0, sizeof( buffer ) );

        if( DeviceIoControl( hPhysicalDriveIOCTL, IOCTL_STORAGE_QUERY_PROPERTY,
              &query,
              sizeof( query ),
              &buffer,
              sizeof( buffer ),
              &cbBytesReturned, NULL ) )
        {
           hb_retclen( buffer + 126, 20 );
        }
        else
           hb_retc( "can't read it" );
           
        CloseHandle( hPhysicalDriveIOCTL );   
    }
    else 
           hb_retc( "can't read it" );
}

#pragma ENDDUMP