centos7 获取CPUID，MAC地址，硬盘序列号，主板序列号命令

过往的日子

centos7 获取CPUID，MAC地址，硬盘序列号，主板序列号命令：

1.CPUID

1. #include <cstdio>
   
2. #include <cstring>
   
3. #include <cstdlib>
   
4. #include <arpa/inet.h>
   
5. #include <string>
   
6. #include <fstream>
   
7. #include <unistd.h>
   
8. 
   
9. static bool get_cpu_id_by_asm(std::string & cpu_id)
   
10. {
    
11.     cpu_id.clear();
    
12. 
    
13.     unsigned int s1 = 0;
    
14.     unsigned int s2 = 0;
    
15.     asm volatile
    
16.     (
    
17.         "movl $0x01, %%eax; \n\t"
    
18.         "xorl %%edx, %%edx; \n\t"
    
19.         "cpuid; \n\t"
    
20.         "movl %%edx, %0; \n\t"
    
21.         "movl %%eax, %1; \n\t"
    
22.         : "=m"(s1), "=m"(s2)
    
23.     );
    
24.     if (0 == s1 && 0 == s2)
    
25.     {
    
26.         return(false);
    
27.     }
    
28.     char cpu[32] = { 0 };
    
29.     snprintf(cpu, sizeof(cpu), "%08X%08X", htonl(s2), htonl(s1));
    
30.     std::string(cpu).swap(cpu_id);
    
31.     return(true);
    
32. }
    
33. static void parse_cpu_id(const char * file_name, const char * match_words, std::string & cpu_id)
    
34. {
    
35.     cpu_id.c_str();
    
36.     std::ifstream ifs(file_name, std::ios::binary);
    
37.     if (!ifs.is_open())
    
38.     {
    
39.         return;
    
40.     }
    
41.     char line[4096] = { 0 };
    
42.     while (!ifs.eof())
    
43.     {
    
44.         ifs.getline(line, sizeof(line));
    
45.         if (!ifs.good())
    
46.         {
    
47.             break;
    
48.         }
    
49.         const char * cpu = strstr(line, match_words);
    
50.         if (NULL == cpu)
    
51.         {
    
52.             continue;
    
53.         }
    
54.         cpu += strlen(match_words);
    
55.         while ('\0' != cpu[0])
    
56.         {
    
57.             if (' ' != cpu[0])
    
58.             {
    
59.                 cpu_id.push_back(cpu[0]);
    
60.             }
    
61.             ++cpu;
    
62.         }
    
63.         if (!cpu_id.empty())
    
64.         {
    
65.             break;
    
66.         }
    
67.     }
    
68.     ifs.close();
    
69. }
    
70. static bool get_cpu_id_by_system(std::string & cpu_id)
    
71. {
    
72.     cpu_id.c_str();
    
73.     const char * dmidecode_result = ".dmidecode_result.txt";
    
74.     char command[512] = { 0 };
    
75.     snprintf(command, sizeof(command), "dmidecode -t 4 | grep ID > %s", dmidecode_result);
    
76.     if (0 == system(command))
    
77.     {
    
78.         parse_cpu_id(dmidecode_result, "ID:", cpu_id);
    
79.     }
    
80.     unlink(dmidecode_result);
    
81.     return(!cpu_id.empty());
    
82. }
    
83. static bool get_cpu_id(std::string & cpu_id)
    
84. {
    
85.     if (get_cpu_id_by_asm(cpu_id))
    
86.     {
    
87.         return(true);
    
88.     }
    
89.     if (0 == getuid())
    
90.     {
    
91.         if (get_cpu_id_by_system(cpu_id))
    
92.         {
    
93.             return(true);
    
94.         }
    
95.     }
    
96.     return(false);
    
97. }
    
98. static void test_1()
    
99. {
    
100.     std::string cpu_id;
     
101.     if (get_cpu_id(cpu_id))
     
102.     {
     
103.         printf("cpu_id: [%s]\n", cpu_id.c_str());
     
104.     }
     
105.     else
     
106.     {
     
107.         printf("can not get cpu id\n");
     
108.     }
     
109. }
     
110. static void test_2()
     
111. {
     
112.     {
     
113.         std::string cpu_id;
     
114.         if (get_cpu_id_by_asm(cpu_id))
     
115.         {
     
116.             printf("cpu_id_by_asm: [%s]\n", cpu_id.c_str());
     
117.         }
     
118.         else
     
119.         {
     
120.             printf("can not get cpu id\n");
     
121.         }
     
122.     }
     
123.     {
     
124.         std::string cpu_id;
     
125.         if (get_cpu_id_by_system(cpu_id))
     
126.         {
     
127.             printf("cpu_id_by_sys: [%s]\n", cpu_id.c_str());
     
128.         }
     
129.         else
     
130.         {
     
131.             printf("can not get cpu id\n");
     
132.         }
     
133.     }
     
134. }

复制代码

2.获取MAC地址： 修复原创 命令获取时 加入000000000000 的问题

1. #include <cstdio>
   
2. #include <cstring>
   
3. #include <cstdlib>
   
4. #include <unistd.h>
   
5. #include <net/if.h>
   
6. #include <sys/ioctl.h>
   
7. #include <sys/types.h>
   
8. #include <sys/socket.h>
   
9. #include <string>
   
10. #include <fstream>
    
11. 
    
12. bool get_mac_address_by_ioctl(std::string & mac_address)
    
13. {
    
14.     mac_address.clear();
    
15. 
    
16.     int sock = socket(AF_INET, SOCK_STREAM, 0);
    
17.     if (sock < 0)
    
18.     {
    
19.         return(false);
    
20.     }
    
21. 
    
22.     struct ifreq ifr = { 0 };
    
23.     strncpy(ifr.ifr_name, "eth0", sizeof(ifr.ifr_name) - 1);
    
24.     bool ret = (ioctl(sock, SIOCGIFHWADDR, &ifr) >= 0);
    
25. 
    
26.     close(sock);
    
27. 
    
28.     const char hex[] =
    
29.     {
    
30.         '0', '1', '2', '3', '4', '5', '6', '7',
    
31.         '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
    
32.     };
    
33.     char mac[16] = { 0 };
    
34.     for (int index = 0; index < 6; ++index)
    
35.     {
    
36.          size_t value = ifr.ifr_hwaddr.sa_data[index] & 0xFF;
    
37.          mac[2 * index + 0] = hex[value / 16];
    
38.          mac[2 * index + 1] = hex[value % 16];
    
39.     }
    
40.     std::string(mac).swap(mac_address);
    
41. 
    
42.     return(ret);
    
43. }
    
44. 
    
45. static void parse_mac_address(const char * file_name, const char * match_words, std::string & mac_address)
    
46. {
    
47.     mac_address.c_str();
    
48. 
    
49.     std::ifstream ifs(file_name, std::ios::binary);
    
50.     if (!ifs.is_open())
    
51.     {
    
52.         return;
    
53.     }
    
54. 
    
55.     char line[4096] = { 0 };
    
56.     while (!ifs.eof())
    
57.     {
    
58.         ifs.getline(line, sizeof(line));
    
59.         if (!ifs.good())
    
60.         {
    
61.             break;
    
62.         }
    
63. 
    
64.         const char * mac = strstr(line, match_words);
    
65.         if (NULL == mac)
    
66.         {
    
67.             continue;
    
68.         }
    
69.         mac += strlen(match_words);
    
70. 
    
71.         while ('\0' != mac[0])
    
72.         {
    
73.             if (' ' != mac[0] && ':' != mac[0])
    
74.             {
    
75.                 mac_address.push_back(mac[0]);
    
76.             }
    
77.             ++mac;
    
78.         }
    
79. 
    
80.         if (!mac_address.empty())
    
81.         {
    
82. 
    
83.            mac_address= mac_address.substr(mac_address.length() - 12, mac_address.length());
    
84.             break;
    
85.         }
    
86.     }
    
87. 
    
88.     ifs.close();
    
89. }
    
90. 
    
91. static bool get_mac_address_by_system(std::string & mac_address)
    
92. {
    
93.     mac_address.c_str();
    
94. 
    
95.     const char * lshw_result = ".lshw_result.txt";
    
96.     char command[512] = { 0 };
    
97.     snprintf(command, sizeof(command), "lshw -c network | grep serial | head -n 1 > %s", lshw_result);
    
98. 
    
99.     if (0 == system(command))
    
100.     {
     
101.         parse_mac_address(lshw_result, "serial:", mac_address);
     
102.     }
     
103. 
     
104.     unlink(lshw_result);
     
105. 
     
106.     return(!mac_address.empty());
     
107. }
     
108. 
     
109. static bool get_mac_address(std::string & mac_address)
     
110. {
     
111.     if (get_mac_address_by_ioctl(mac_address))
     
112.     {
     
113.         return(true);
     
114.     }
     
115.     if (get_mac_address_by_system(mac_address))
     
116.     {
     
117.         return(true);
     
118.     }
     
119.     return(false);
     
120. }
     
121. 
     
122. static void test_1()
     
123. {
     
124.     std::string mac_address;
     
125.     if (get_mac_address(mac_address))
     
126.     {
     
127.         printf("mac_address: [%s]\n", mac_address.c_str());
     
128.     }
     
129.     else
     
130.     {
     
131.         printf("can not get mac address\n");
     
132.     }
     
133. }
     
134. 
     
135. static void test_2()
     
136. {
     
137.     {
     
138.         std::string mac_address;
     
139.         if (get_mac_address_by_ioctl(mac_address))
     
140.         {
     
141.             printf("mac_address: [%s]\n", mac_address.c_str());
     
142.         }
     
143.         else
     
144.         {
     
145.             printf("can not get mac address\n");
     
146.         }
     
147.     }
     
148.     {
     
149.         std::string mac_address;
     
150.         if (get_mac_address_by_system(mac_address))
     
151.         {
     
152.             printf("mac_address: [%s]\n", mac_address.c_str());
     
153.         }
     
154.         else
     
155.         {
     
156.             printf("can not get mac address\n");
     
157.         }
     
158.     }
     
159. }

复制代码

获取硬盘序列号：

1. #include <cctype>
   
2. #include <cstdlib>
   
3. #include <cstring>
   
4. #include <fcntl.h>
   
5. #include <unistd.h>
   
6. #include <scsi/sg.h>
   
7. #include <sys/ioctl.h>
   
8. #include <linux/hdreg.h>
   
9. #include <string>
   
10. #include <fstream>
    
11. 
    
12. static bool get_disk_name(std::string & disk_name)
    
13. {
    
14.     disk_name.c_str();
    
15. 
    
16.     std::ifstream ifs("/etc/mtab", std::ios::binary);
    
17.     if (!ifs.is_open())
    
18.     {
    
19.         return(false);
    
20.     }
    
21. 
    
22.     char line[4096] = { 0 };
    
23.     while (!ifs.eof())
    
24.     {
    
25.         ifs.getline(line, sizeof(line));
    
26.         if (!ifs.good())
    
27.         {
    
28.             break;
    
29.         }
    
30. 
    
31.         const char * disk = line;
    
32.         while (isspace(disk[0]))
    
33.         {
    
34.             ++disk;
    
35.         }
    
36. 
    
37.         const char * space = strchr(disk, ' ');
    
38.         if (NULL == space)
    
39.         {
    
40.             continue;
    
41.         }
    
42. 
    
43.         const char * mount = space + 1;
    
44.         while (isspace(mount[0]))
    
45.         {
    
46.             ++mount;
    
47.         }
    
48.         if ('/' != mount[0] || ' ' != mount[1])
    
49.         {
    
50.             continue;
    
51.         }
    
52. 
    
53.         while (space > disk && isdigit(space[-1]))
    
54.         {
    
55.             --space;
    
56.         }
    
57. 
    
58.         if (space > disk)
    
59.         {
    
60.             std::string(disk, space).swap(disk_name);
    
61.             break;
    
62.         }
    
63.     }
    
64. 
    
65.     ifs.close();
    
66. 
    
67.     return(!disk_name.empty());
    
68. }
    
69. 
    
70. static void trim_serial(const void * serial, size_t serial_len, std::string & serial_no)
    
71. {
    
72.     const char * serial_s = static_cast<const char *>(serial);
    
73.     const char * serial_e = serial_s + serial_len;
    
74.     while (serial_s < serial_e)
    
75.     {
    
76.         if (isspace(serial_s[0]))
    
77.         {
    
78.             ++serial_s;
    
79.         }
    
80.         else if ('\0' == serial_e[-1] || isspace(serial_e[-1]))
    
81.         {
    
82.             --serial_e;
    
83.         }
    
84.         else
    
85.         {
    
86.             break;
    
87.         }
    
88.     }
    
89. 
    
90.     if (serial_s < serial_e)
    
91.     {
    
92.         std::string(serial_s, serial_e).swap(serial_no);
    
93.     }
    
94. }
    
95. 
    
96. static bool get_disk_serial_by_way_1(const std::string & disk_name, std::string & serial_no)
    
97. {
    
98.     serial_no.clear();
    
99. 
    
100.     int fd = open(disk_name.c_str(), O_RDONLY);
     
101.     if (-1 == fd)
     
102.     {
     
103.         return(false);
     
104.     }
     
105. 
     
106.     struct hd_driveid drive = { 0 };
     
107.     if (0 == ioctl(fd, HDIO_GET_IDENTITY, &drive))
     
108.     {
     
109.         trim_serial(drive.serial_no, sizeof(drive.serial_no), serial_no);
     
110.     }
     
111. 
     
112.     close(fd);
     
113. 
     
114.     return(!serial_no.empty());
     
115. }
     
116. 
     
117. static bool scsi_io(
     
118.                 int fd, unsigned char * cdb,
     
119.                 unsigned char cdb_size, int xfer_dir,
     
120.                 unsigned char * data, unsigned int data_size,
     
121.                 unsigned char * sense, unsigned int sense_len
     
122.             )
     
123. {
     
124.     sg_io_hdr_t io_hdr = { 0 };
     
125.     io_hdr.interface_id = 'S';
     
126.     io_hdr.cmdp = cdb;
     
127.     io_hdr.cmd_len = cdb_size;
     
128.     io_hdr.sbp = sense;
     
129.     io_hdr.mx_sb_len = sense_len;
     
130.     io_hdr.dxfer_direction = xfer_dir;
     
131.     io_hdr.dxferp = data;
     
132.     io_hdr.dxfer_len = data_size;
     
133.     io_hdr.timeout = 5000;
     
134. 
     
135.     if (ioctl(fd, SG_IO, &io_hdr) < 0)
     
136.     {
     
137.         return(false);
     
138.     }
     
139. 
     
140.     if (SG_INFO_OK != (io_hdr.info & SG_INFO_OK_MASK) && io_hdr.sb_len_wr > 0)
     
141.     {
     
142.         return(false);
     
143.     }
     
144. 
     
145.     if (io_hdr.masked_status || io_hdr.host_status || io_hdr.driver_status)
     
146.     {
     
147.         return(false);
     
148.     }
     
149. 
     
150.     return(true);
     
151. }
     
152. 
     
153. static bool get_disk_serial_by_way_2(const std::string & disk_name, std::string & serial_no)
     
154. {
     
155.     serial_no.clear();
     
156. 
     
157.     int fd = open(disk_name.c_str(), O_RDONLY);
     
158.     if (-1 == fd)
     
159.     {
     
160.         return(false);
     
161.     }
     
162. 
     
163.     int version = 0;
     
164.     if (ioctl(fd, SG_GET_VERSION_NUM, &version) < 0 || version < 30000)
     
165.     {
     
166.         close(fd);
     
167.         return(false);
     
168.     }
     
169. 
     
170.     const unsigned int data_size = 0x00ff;
     
171.     unsigned char data[data_size] = { 0 };
     
172.     const unsigned int sense_len = 32;
     
173.     unsigned char sense[sense_len] = { 0 };
     
174.     unsigned char cdb[] = { 0x12, 0x01, 0x80, 0x00, 0x00, 0x00 };
     
175.     cdb[3] = (data_size >> 8) & 0xff;
     
176.     cdb[4] = (data_size & 0xff);
     
177. 
     
178.     if (scsi_io(fd, cdb, sizeof(cdb), SG_DXFER_FROM_DEV, data, data_size, sense, sense_len))
     
179.     {
     
180.         int page_len = data[3];
     
181.         trim_serial(data + 4, page_len, serial_no);
     
182.     }
     
183. 
     
184.     close(fd);
     
185. 
     
186.     return(!serial_no.empty());
     
187. }
     
188. 
     
189. static bool parse_serial(const char * line, int line_size, const char * match_words, std::string & serial_no)
     
190. {
     
191.     const char * serial_s = strstr(line, match_words);
     
192.     if (NULL == serial_s)
     
193.     {
     
194.         return(false);
     
195.     }
     
196.     serial_s += strlen(match_words);
     
197.     while (isspace(serial_s[0]))
     
198.     {
     
199.         ++serial_s;
     
200.     }
     
201. 
     
202.     const char * serial_e = line + line_size;
     
203.     const char * comma = strchr(serial_s, ',');
     
204.     if (NULL != comma)
     
205.     {
     
206.         serial_e = comma;
     
207.     }
     
208. 
     
209.     while (serial_e > serial_s && isspace(serial_e[-1]))
     
210.     {
     
211.         --serial_e;
     
212.     }
     
213. 
     
214.     if (serial_e <= serial_s)
     
215.     {
     
216.         return(false);
     
217.     }
     
218. 
     
219.     std::string(serial_s, serial_e).swap(serial_no);
     
220. 
     
221.     return(true);
     
222. }
     
223. 
     
224. static void get_serial(const char * file_name, const char * match_words, std::string & serial_no)
     
225. {
     
226.     serial_no.c_str();
     
227. 
     
228.     std::ifstream ifs(file_name, std::ios::binary);
     
229.     if (!ifs.is_open())
     
230.     {
     
231.         return;
     
232.     }
     
233. 
     
234.     char line[4096] = { 0 };
     
235.     while (!ifs.eof())
     
236.     {
     
237.         ifs.getline(line, sizeof(line));
     
238.         if (!ifs.good())
     
239.         {
     
240.             break;
     
241.         }
     
242. 
     
243.         if (0 == ifs.gcount())
     
244.         {
     
245.             continue;
     
246.         }
     
247. 
     
248.         if (parse_serial(line, ifs.gcount() - 1, match_words, serial_no))
     
249.         {
     
250.             break;
     
251.         }
     
252.     }
     
253. 
     
254.     ifs.close();
     
255. }
     
256. 
     
257. static bool get_disk_serial_by_way_3(const std::string & disk_name, std::string & serial_no)
     
258. {
     
259.     serial_no.c_str();
     
260. 
     
261.     const char * hdparm_result = ".hdparm_result.txt";
     
262.     char command[512] = { 0 };
     
263.     snprintf(command, sizeof(command), "hdparm -i %s | grep SerialNo > %s", disk_name.c_str(), hdparm_result);
     
264. 
     
265.     if (0 == system(command))
     
266.     {
     
267.         get_serial(hdparm_result, "SerialNo=", serial_no);
     
268.     }
     
269. 
     
270.     unlink(hdparm_result);
     
271. 
     
272.     return(!serial_no.empty());
     
273. }
     
274. 
     
275. static bool get_disk_serial_by_way_4(std::string & serial_no)
     
276. {
     
277.     serial_no.c_str();
     
278. 
     
279.     const char * lshw_result = ".lshw_result.txt";
     
280.     char command[512] = { 0 };
     
281.     snprintf(command, sizeof(command), "lshw -class disk | grep serial > %s", lshw_result);
     
282. 
     
283.     if (0 == system(command))
     
284.     {
     
285.         get_serial(lshw_result, "serial:", serial_no);
     
286.     }
     
287. 
     
288.     unlink(lshw_result);
     
289. 
     
290.     return(!serial_no.empty());
     
291. }
     
292. 
     
293. static bool get_disk_serial_number(std::string & serial_no)
     
294. {
     
295.     if (0 != getuid())
     
296.     {
     
297.         return(false);
     
298.     }
     
299. 
     
300.     std::string disk_name;
     
301.     if (get_disk_name(disk_name))
     
302.     {
     
303.         if (get_disk_serial_by_way_1(disk_name, serial_no))
     
304.         {
     
305.             return(true);
     
306.         }
     
307.         if (get_disk_serial_by_way_2(disk_name, serial_no))
     
308.         {
     
309.             return(true);
     
310.         }
     
311.         if (get_disk_serial_by_way_3(disk_name, serial_no))
     
312.         {
     
313.             return(true);
     
314.         }
     
315.     }
     
316.     if (get_disk_serial_by_way_4(serial_no))
     
317.     {
     
318.         return(true);
     
319.     }
     
320.     return(false);
     
321. }
     
322. 
     
323. static void test_1()
     
324. {
     
325.     std::string serial_no;
     
326.     if (get_disk_serial_number(serial_no))
     
327.     {
     
328.         printf("serial_number: [%s]\n", serial_no.c_str());
     
329.     }
     
330.     else
     
331.     {
     
332.         printf("get serial number failed\n");
     
333.     }
     
334. }
     
335. 
     
336. static void test_2()
     
337. {
     
338.     std::string disk_name;
     
339.     if (get_disk_name(disk_name))
     
340.     {
     
341.         printf("disk_name:[%s]\n", disk_name.c_str());
     
342.         {
     
343.             std::string serial_no;
     
344.             get_disk_serial_by_way_1(disk_name, serial_no);
     
345.             printf("get_serial_by_way_1:[%s]\n", serial_no.c_str());
     
346.         }
     
347.         {
     
348.             std::string serial_no;
     
349.             get_disk_serial_by_way_2(disk_name, serial_no);
     
350.             printf("get_serial_by_way_2:[%s]\n", serial_no.c_str());
     
351.         }
     
352.         {
     
353.             std::string serial_no;
     
354.             get_disk_serial_by_way_3(disk_name, serial_no);
     
355.             printf("get_serial_by_way_3:[%s]\n", serial_no.c_str());
     
356.         }
     
357.     }
     
358.     {
     
359.         std::string serial_no;
     
360.         get_disk_serial_by_way_4(serial_no);
     
361.         printf("get_serial_by_way_4:[%s]\n", serial_no.c_str());
     
362.     }
     
363. }

复制代码

获取主板序列号：

1. #include <cstdio>
   
2. #include <cstring>
   
3. #include <cstdlib>
   
4. #include <string>
   
5. #include <fstream>
   
6. 
   
7. static void parse_board_serial(const char * file_name, const char * match_words, std::string & board_serial)
   
8. {
   
9.     board_serial.c_str();
   
10. 
    
11.     std::ifstream ifs(file_name, std::ios::binary);
    
12.     if (!ifs.is_open())
    
13.     {
    
14.         return;
    
15.     }
    
16. 
    
17.     char line[4096] = { 0 };
    
18.     while (!ifs.eof())
    
19.     {
    
20.         ifs.getline(line, sizeof(line));
    
21.         if (!ifs.good())
    
22.         {
    
23.             break;
    
24.         }
    
25. 
    
26.         const char * board = strstr(line, match_words);
    
27.         if (NULL == board)
    
28.         {
    
29.             continue;
    
30.         }
    
31.         board += strlen(match_words);
    
32. 
    
33.         while ('\0' != board[0])
    
34.         {
    
35.             if (' ' != board[0])
    
36.             {
    
37.                 board_serial.push_back(board[0]);
    
38.             }
    
39.             ++board;
    
40.         }
    
41. 
    
42.         if ("None" == board_serial)
    
43.         {
    
44.             board_serial.clear();
    
45.             continue;
    
46.         }
    
47. 
    
48.         if (!board_serial.empty())
    
49.         {
    
50.             break;
    
51.         }
    
52.     }
    
53. 
    
54.     ifs.close();
    
55. }
    
56. 
    
57. static bool get_board_serial_by_system(std::string & board_serial)
    
58. {
    
59.     board_serial.c_str();
    
60. 
    
61.     const char * dmidecode_result = ".dmidecode_result.txt";
    
62.     char command[512] = { 0 };
    
63.     snprintf(command, sizeof(command), "dmidecode -t 2 | grep Serial > %s", dmidecode_result);
    
64. 
    
65.     if (0 == system(command))
    
66.     {
    
67.         parse_board_serial(dmidecode_result, "Serial Number:", board_serial);
    
68.     }
    
69. 
    
70.     unlink(dmidecode_result);
    
71. 
    
72.     return(!board_serial.empty());
    
73. }
    
74. 
    
75. static bool get_board_serial_number(std::string & board_serial)
    
76. {
    
77.     if (0 == getuid())
    
78.     {
    
79.         if (get_board_serial_by_system(board_serial))
    
80.         {
    
81.             return(true);
    
82.         }
    
83.     }
    
84.     return(false);
    
85. }
    
86. 
    
87. static void test()
    
88. {
    
89.     std::string board_serial;
    
90.     if (get_board_serial_number(board_serial))
    
91.     {
    
92.         printf("board_serial: [%s]\n", board_serial.c_str());
    
93.     }
    
94.     else
    
95.     {
    
96.         printf("can not get board id\n");
    
97.     }
    
98. }

复制代码