Серийный номер флэшки

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

#include <vcl.h>
#include <stdio.h>
#include <iostream.h>
#include <winioctl.h>
#include "HDDSerial.h"
cHDD Hdd;
using namespace std;
//---------------------------------------------------------------------------
//#define PRINTING_TO_CONSOLE_ALLOWED

char * cHDD::flipAndCodeBytes (char * str)
{
    static char flipped [1000];
    int i = 0;
    int j = 0;
    int k = 0;
    int num = strlen (str);

    strcpy (flipped, "");
    for (i = 0; i < num; i += 4)
    {
        for (j = 1; j >= 0; j--)
        {
            int sum = 0;
            for (k = 0; k < 2; k++)
            {
                sum *= 16;
                switch (str [i + j * 2 + k])
                {
                case '0': sum += 0; break;
                case '1': sum += 1; break;
                case '2': sum += 2; break;
                case '3': sum += 3; break;
                case '4': sum += 4; break;
                case '5': sum += 5; break;
                case '6': sum += 6; break;
                case '7': sum += 7; break;
                case '8': sum += 8; break;
                case '9': sum += 9; break;
                case 'a': sum += 10; break;
                case 'b': sum += 11; break;
                case 'c': sum += 12; break;
                case 'd': sum += 13; break;
                case 'e': sum += 14; break;
                case 'f': sum += 15; break;
                case 'A': sum += 10; break;
                case 'B': sum += 11; break;
                case 'C': sum += 12; break;
                case 'D': sum += 13; break;
                case 'E': sum += 14; break;
                case 'F': sum += 15; break;
                }
            }
            if (sum > 0)
            {
                char sub [2];
                sub [0] = (char) sum;
                sub [1] = 0;
                strcat (flipped, sub);
            }
        }
    }

    return flipped;
}
char* cHDD::ReadPhysicalDriveInNTWithZeroRights (int drive)
{
//   int drive = 0;
    char *serialNumber = new char[1000];
    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);

         //  Windows NT, Windows 2000, Windows XP - admin rights not required
    hPhysicalDriveIOCTL = CreateFile (driveName, 0,
                               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)
      {
         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) )
         {        
             STORAGE_DEVICE_DESCRIPTOR * descrip = (STORAGE_DEVICE_DESCRIPTOR *) & buffer;
//           char serialNumber [1000];
             char modelNumber [1000];

             strcpy (serialNumber,
                     flipAndCodeBytes ( & buffer [descrip -> SerialNumberOffset]));
             strcpy (modelNumber, & buffer [descrip -> ProductIdOffset]);
             if (0 == HardDriveSerialNumber [0] &&
                        //  serial number must be alphanumeric
                        //  (but there can be leading spaces on IBM drives)
                   (isalnum (serialNumber [0]) || isalnum (serialNumber [19])))
             {
                strcpy (HardDriveSerialNumber, serialNumber);
                strcpy (HardDriveModelNumber, modelNumber);
             }
#ifdef PRINTING_TO_CONSOLE_ALLOWED
             printf ("\n**** STORAGE_DEVICE_DESCRIPTOR for drive %d ****\n"
                     "Vendor Id = %s\n"
                     "Product Id = %s\n"
                     "Product Revision = %s\n"
                     "Serial Number = %s\n",
                     drive,
                     & buffer [descrip -> VendorIdOffset],
                     & buffer [descrip -> ProductIdOffset],
                     & buffer [descrip -> ProductRevisionOffset],
                     serialNumber);
#endif
         }
         else
         {
             DWORD err = GetLastError ();
#ifdef PRINTING_TO_CONSOLE_ALLOWED
             printf ("\nDeviceIOControl IOCTL_STORAGE_QUERY_PROPERTY error = %d\n", err);
#endif
         }

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

         if ( DeviceIoControl (hPhysicalDriveIOCTL, IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER,
                   NULL,
                   0,
                   & buffer,
                   sizeof (buffer),
                   & cbBytesReturned, NULL) )
         {
     MEDIA_SERIAL_NUMBER_DATA * mediaSerialNumber =
                            (MEDIA_SERIAL_NUMBER_DATA *) & buffer;
//           char serialNumber [1000];
             // char modelNumber [1000];

             strcpy (serialNumber, (char *) mediaSerialNumber -> SerialNumberData);
             // strcpy (modelNumber, & buffer [descrip -> ProductIdOffset]);
             if (0 == HardDriveSerialNumber [0] &&
                        //  serial number must be alphanumeric
                        //  (but there can be leading spaces on IBM drives)
                   (isalnum (serialNumber [0]) || isalnum (serialNumber [19])))
             {
                strcpy (HardDriveSerialNumber, serialNumber);
                // strcpy (HardDriveModelNumber, modelNumber);
             }
#ifdef PRINTING_TO_CONSOLE_ALLOWED
             printf ("\n**** MEDIA_SERIAL_NUMBER_DATA for drive %d ****\n"
                     "Serial Number = %s\n",
                     drive, serialNumber);
#endif
         }
         else
         {
             DWORD err = GetLastError ();
#ifdef PRINTING_TO_CONSOLE_ALLOWED
             switch (err)
             {
             case 1:
                 printf ("\nDeviceIOControl IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER error = \n"
                            "              The request is not valid for this device.\n\n");
                 break;
             case 50:
                 printf ("\nDeviceIOControl IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER error = \n"
                            "              The request is not supported for this device.\n\n");
                 break;
             default:
                 printf ("\nDeviceIOControl IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER error = %d\n\n", err);
             }
#endif
         }

         CloseHandle (hPhysicalDriveIOCTL);
      }
   while(serialNumber[0] == ' ')
    *serialNumber++;

   return serialNumber;
}
//---------------------------------------------------------------------------

#ifndef _HDDSERIAL
#define _HDDSERIAL
    class cHDD
    {
        private:
            typedef struct _MEDIA_SERAL_NUMBER_DATA
            {
                ULONG  SerialNumberLength;
                ULONG  Result;
                ULONG  Reserved[2];
                UCHAR  SerialNumberData[1];
            } MEDIA_SERIAL_NUMBER_DATA, *PMEDIA_SERIAL_NUMBER_DATA;
            char HardDriveSerialNumber [1024];
            char HardDriveModelNumber [1024];
            char * flipAndCodeBytes (char * str);
        public:
            char* ReadPhysicalDriveInNTWithZeroRights (int drive);
    };
    extern cHDD Hdd;
#endif

hPhysicalDriveIOCTL = CreateFile (driveName, 0,
                               FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                               OPEN_EXISTING, 0, NULL);