一个简单的磁盘序列号获取类

harddiskinfo.h

点击(此处)折叠或打开

1. #ifndef HARDDISK_H
   
2. #define HARDDISK_H
   
3. 
   
4. #include <string>
   
5. 
   
6. #define SCSI_TIMEOUT 5000 /* ms */
   
7. 
   
8. class HardDiskInfo
   
9. {
   
10. public:
    
11.     HardDiskInfo(std::string name);
    
12.     ~HardDiskInfo();
    
13.     std::string serial_number();
    
14. 
    
15. private:
    
16.     void initialize();
    
17.     int device_fd;
    
18.     std::string device_name;
    
19. };
    
20. 
    
21. #endif /*HARDDISK_H*/

harddiskinfo.cpp

点击(此处)折叠或打开

1. #include "harddiskinfo.h"
   
2. 
   
3. #include <string.h>
   
4. #include <cstdio>
   
5. #include <cstdlib>
   
6. #include <cerrno>
   
7. 
   
8. #include <fcntl.h>
   
9. #include <unistd.h>
   
10. #include <linux/types.h>
    
11. #include <linux/hdreg.h>
    
12. #include <sys/ioctl.h>
    
13. #include <sys/types.h>
    
14. #include <sys/stat.h>
    
15. #include <sys/ioctl.h>
    
16. #include <scsi/sg.h>
    
17. 
    
18. #include <iostream>
    
19. 
    
20. using std::cerr;
    
21. using std::endl;
    
22. using std::hex;
    
23. 
    
24. HardDiskInfo::HardDiskInfo(std::string name) :
    
25.     device_name(name)
    
26. {
    
27.     initialize();
    
28. }
    
29. 
    
30. HardDiskInfo::~HardDiskInfo()
    
31. {
    
32.     close(device_fd);
    
33. }
    
34. static int scsi_io(int fd, unsigned char *cdb, unsigned char cdb_size, int xfer_dir,
    
35.         unsigned char *data, unsigned int *data_size,
    
36.         unsigned char *sense, unsigned int *sense_len)
    
37. {
    
38.     sg_io_hdr_t io_hdr;
    
39. 
    
40.     memset(&io_hdr, 0, sizeof(sg_io_hdr_t));
    
41.     io_hdr.interface_id = 'S';
    
42. 
    
43.     io_hdr.cmdp = cdb;
    
44.     io_hdr.cmd_len = cdb_size;
    
45. 
    
46.     /* Where to store the sense_data, if there was an error */
    
47.     io_hdr.sbp = sense;
    
48.     io_hdr.mx_sb_len = *sense_len;
    
49.     *sense_len=0;
    
50. 
    
51.     /*
    
52.      * Transfer direction, either in or out. Linux does not yet
    
53.      * support bidirectional SCSI transfers ?
    
54.      */
    
55.     io_hdr.dxfer_direction = xfer_dir;
    
56. 
    
57.     /*
    
58.      * Where to store the DATA IN/OUT from the device and how big the
    
59.      * buffer is
    
60.      */
    
61.     io_hdr.dxferp = data;
    
62.     io_hdr.dxfer_len = *data_size;
    
63. 
    
64.     /* SCSI timeout in ms */
    
65.     io_hdr.timeout = SCSI_TIMEOUT;
    
66. 
    
67.     if(ioctl(fd, SG_IO, &io_hdr) < 0)
    
68.     {
    
69.         perror("SG_IO ioctl error");
    
70.         return -1;
    
71.     }
    
72. 
    
73.     /* now for the error processing */
    
74.     if((io_hdr.info & SG_INFO_OK_MASK) != SG_INFO_OK)
    
75.     {
    
76.         if(io_hdr.sb_len_wr > 0)
    
77.         {
    
78.             *sense_len=io_hdr.sb_len_wr;
    
79.             return 0;
    
80.         }
    
81.     }
    
82.     if(io_hdr.masked_status)
    
83.     {
    
84.         cerr << "status: 0x" << hex << io_hdr.status << endl;
    
85.         cerr << "masked_status: 0x" << hex << io_hdr.masked_status << endl;
    
86.         return -2;
    
87.     }
    
88.     if(io_hdr.host_status)
    
89.     {
    
90.         cerr << "host_status: 0x" << hex << io_hdr.host_status << endl;
    
91.         return -3;
    
92.     }
    
93.     if(io_hdr.driver_status)
    
94.     {
    
95.         cerr << "driver_status: 0x" << hex << io_hdr.driver_status << endl;
    
96.         return -4;
    
97.     }
    
98.     return 0;
    
99. }
    
100. 
     
101. static void device_serial_num(int device_fd, std::string *serial_number)
     
102. {
     
103.     unsigned char cdb[] = {0x12,0x01,0x80,0,0,0};
     
104.     unsigned int data_size = 0x00ff;
     
105.     unsigned char data[data_size];
     
106.     unsigned int sense_len = 32;
     
107.     unsigned char sense[sense_len];
     
108.     char result[32] = {0};
     
109.     int res, pl, i;
     
110. 
     
111.     cdb[3] = (data_size >>8) & 0xff;
     
112.     cdb[4] = data_size & 0xff;
     
113. 
     
114.     res=scsi_io(device_fd, cdb, sizeof(cdb), SG_DXFER_FROM_DEV, data, &data_size, sense, &sense_len);
     
115.     if(res)
     
116.     {
     
117.         perror("ioctl(SG_DXFER_FROM_DEV) error");
     
118.     }
     
119.     if(sense_len)
     
120.     {
     
121.         ;
     
122.     }
     
123. 
     
124.     /* Page Length */
     
125.     pl=data[3];
     
126.     int m = 0;
     
127.     for(i = 4;i < (pl + 4); i++)
     
128.         result[m++] = data[i] & 0xff;
     
129.     serial_number->assign(result);
     
130. }
     
131. 
     
132. std::string HardDiskInfo::serial_number()
     
133. {
     
134.     std::string hd_serno;
     
135.     device_serial_num(device_fd, &hd_serno);
     
136. 
     
137.     return hd_serno;
     
138. }
     
139. 
     
140. void HardDiskInfo::initialize()
     
141. {
     
142.     int vers;
     
143.     device_fd = open(device_name.c_str(), O_RDONLY);
     
144.     if (device_fd == -1)
     
145.     {
     
146.         perror("Can not open the specified device");
     
147.         exit(EXIT_FAILURE);
     
148.     }
     
149.     if ((ioctl(device_fd, SG_GET_VERSION_NUM, &vers) < 0) || (vers < 30000))
     
150.     {
     
151.         perror("The specified device is not a sg device, or old sg device");
     
152.         close(device_fd);
     
153.         exit(EXIT_FAILURE);
     
154.     }
     
155. }