C语言读取GPT分区信息_windows c++ 怎样读取gpt 硬盘上数据库文件

最近作业需要读取MBR和GPT磁盘信息，上次读了MRB，这次读GPT

GPT分区结构

　　GPT的分区格式，比MBR的要简明扼要不少。一开始第一扇区是PMBR，格式与MBR相同，但是作用不同，在GPT中，PMBR没有太多实质性作用，只有第一个分区表项中有内容。
　　第1个扇区，是GPT表头GPT Header，有512字节的大小。GPT表头与MBR作用类似，标志着分区格式的开始。第2个扇区开始，一般连着32个扇区，里面存放的内容是GPT的分区表项。分区表项的作用与MBR中的分区表类似，都是指明了分区在哪里，有多大或者分区范围是多少。与MBR不同的地方是，MBR中每个MBR中只有4个分区条目，要么有4个主分区，要么3个主分区加1个主扩展分区；在EBR中4个分区条目只有前两个用上了，形成类似链表一样的结构，前一个逻辑分区指向后一个，前者说明后者在哪里。GPT中，在windows中可以有128个分区项，就像数组一样，可以直接索引，不需要像链表一样，一个个遍历。
　　GPT分区表项之后有一部分没有用上的区域，然后开始是GPT的第1个分区，一直到最后一个分区。最后一个分区之后，是备份的GPT分区表，最后最后一个扇区，是备份的GPT表头。

PMBR

  protective MBR的作用和MBR是不一样的，内容也不一样，PMBR中，分区表中只有第一个表项有内容。PMBR内容如下，主要关注从第1字节起，第5字节的分区标志和Relative这4字节的内容：

GPT Header

  其中GUID顺序在磁盘中顺序是从低高，而 GUID读取出来需要是一种特殊的顺序
磁盘GUID：B9 8D F9 E9 13 4A 4D 49 99 8F B3 19 FD B7 60 30
读取出来是：E9F98DB9-4A13-494D-998F-B319FDB76030

GPT表项

  其中GUID的顺序和之前第三部分中磁盘GUID的顺序是一致的。表明分区类型的PartitionType微软文档中提供了如下几种：

  分区的属性标志GPT attributes bits的含义微软做了如下规定，需要注意的是，磁盘中是小端的顺序，高位在高地址，需要转换成数字中的顺序做比较。一旦某个二进制位置位上去了，该分区就具有了该种属性。置位可以置多个位。

源代码

使用的打开设备和I/O的函数与上一篇中读取MBR格式磁盘信息是一致的。

#include <windows.h>
#include <winioctl.h> //DDK驱动开发与控制
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <stdint.h>

struct gpt_header //GPT表头512字节
{
	uint8_t signature[8];//无符号8字节签名
	uint8_t version[4];//4字节版本号
	uint8_t headersize[4];//GPT表头大小
	uint8_t headercrc32[4];//GPT表头的CRC-32校验
	uint8_t reserve[4];//保留，为0
	uint8_t header_lba[8];//表头的扇区号
	uint8_t backup_lba[8];//备份表头的扇区号
	uint8_t pation_first_lba[8];//GPT分区起始扇区号
	uint8_t pation_last_lba[8];//GPT分区结束扇区号
	uint8_t guid[16];//磁盘的GUID
	uint8_t pation_table_first[8];//分区表起始扇区号
	uint8_t pation_table_entries[4];//分区表总项数
	uint8_t pation_table_size[4];//单个分区表占用字节数
	uint8_t pation_table_crc[4];//分区表的CRC校验
	uint8_t notuse[420];//保留的420字节
};//GPT表头结构

struct partition_table//分区表是128字节
{
	uint8_t pationtype[16];//分区类型，全0是未使用
	uint8_t pationid[16];//分区唯一标识符
	uint8_t pation_start[8];//分区起始扇区号
	uint8_t pation_end[8];//分区结束扇区号
	uint8_t pation_attr[8];//分区属性标志,区分分区是什么类型的
	uint8_t pation_name[72];//分区名
};

struct MBR_disk_entry
{
	uint8_t bootflag;//引导标志
	uint8_t citouhao;//磁头号
	uint8_t shanquhao;//扇区号
	uint8_t zhumianhao;//柱面号
	uint8_t disk_flag;//分区类型标志，如果是05H/0FH是扩展分区；GPT是0xEE
	uint8_t someinfo[3];
	uint8_t relative[4];//相对起始扇区
	uint8_t sectors[4];//总扇区数
};

struct PMBR    //不是真正的MBR
{
	uint8_t boot_code[446];//引导代码
	MBR_disk_entry pation_table_entry[4];//4个分区表，每个16字节,只有一个分区表有内容，对应的标志是0xEE，
	uint8_t endflag[2];//55AA
};

//PartitionType
uint8_t PARTITION_BASIC_DATA_GUID[16] = {0xeb,0xd0,0xa0,0xa2,0xb9,0xe5,0x44,0x33,
										0x87,0xc0,0x68,0xb6,0xb7,0x26,0x99,0xc7 };
uint8_t PARTITION_SYSTEM_GUID[16] = {0xc1,0x2a,0x73,28,0xf8,0x1f,0x11,0xd2,0xba,
										0x4b,0x00,0xa0,0xc9,0x3e,0xc9,0x3b };
uint8_t PARTITION_MSFT_RESERVED_GUID[16] = {0xe3,0xc9,0xe3,0x16,0x0b,0x5c,0x4d,0xb8,
											0x81,0x7d,0xf9,0x2d,0xf0,0x02,0x15,0xae};
uint8_t PARTITION_MSFT_RECOVERY_GUID[16] = {0xde,0x94,0xbb,0xa4,0x06,0xd1,0x4d,0x40,0xa1,
											0x6a,0xbf,0xd5,0x01,0x79,0xd6,0xac };
uint8_t PARTITION_ENTRY_UNUSED_GUID[16] = { 0 };
uint8_t * partitiontype[5] = { PARTITION_BASIC_DATA_GUID,PARTITION_SYSTEM_GUID ,
				PARTITION_MSFT_RESERVED_GUID ,PARTITION_MSFT_RECOVERY_GUID,PARTITION_ENTRY_UNUSED_GUID };

const char * partition_type_info[] = { "这是一个基本数据分区","这是一个EFI系统分区","这是一个微软保留分区",
										"这是一个微软恢复分区","这是一个空分区"};


//GPT表项的attributes bits的最高位，也就是最左边的1位，索引是[0]
//相与不为0说明置位了
uint64_t read_only =0x1000000000000000;
uint64_t shadow_copy = 0x2000000000000000;//其它分区的影像0x200000....
uint64_t hide_partition = 0x4000000000000000; //Hides a partition's volume.
uint64_t no_letter = 0x8000000000000000;//不自动挂载，没有盘符的
uint64_t EFI_hide = 0x0000000000000010;//EFI不可见分区
uint64_t system_partition = 0x0000000000000001;//系统分区
uint64_t attribute_bits[6] = {read_only,shadow_copy,hide_partition,no_letter,EFI_hide,system_partition};
const char * attribute_bits_info[] = {"这是一个只读分区","这是一个其它分区的shadow copy\n","这是一个隐藏分区",
									"这是一个不自动挂载、不自动分配盘符的分区","这是一个EFI不可见分区",
									"这是一个系统分区"};



uint32_t uint8to32(uint8_t fouruint8[4]) {
	return *(uint32_t*)fouruint8;
	//return((uint32_t)fouruint8[3] << 24) | ((uint32_t)fouruint8[2] << 16) | ((uint32_t)fouruint8[1] << 8) | ((uint32_t)fouruint8[0]);
}

uint64_t uint8to64(uint8_t fouruint8[8]) {
	return *(uint64_t*)fouruint8;
	//return((uint64_t)fouruint8[7] << 56) | ((uint64_t)fouruint8[6] << 48) | ((uint64_t)fouruint8[5] << 40) | ((uint64_t)fouruint8[4] << 32) |
		//((uint64_t)fouruint8[3] << 24) | ((uint64_t)fouruint8[2] << 16) | ((uint64_t)fouruint8[1] << 8) | ((uint64_t)fouruint8[0]);;
}

int compareuint8(uint8_t * a, uint8_t *b)
{
	if (sizeof(*a) != sizeof(*b))
		return 0;
	for (int i = 0; i < sizeof(*a); i++)
	{
		if (a[i] != b[i])
			return 0;
	}
	return 1;
}

void changeseqGUID(uint8_t *GUID, uint8_t *seqGUID)
{
	//最左边4位，是大端，转过来
	seqGUID[0] = GUID[3]; seqGUID[1] = GUID[2]; seqGUID[2] = GUID[1]; seqGUID[3] = GUID[0];
	//交叉顺序
	seqGUID[4] = GUID[5]; seqGUID[5] = GUID[4]; seqGUID[6] = GUID[7]; seqGUID[7] = GUID[6];
	//顺序
	for (int i = 8; i < 16; i++)
		seqGUID[i] = GUID[i];
}

void show_partion_name(uint8_t*beginchar,int length) {
	int j = 0;
	for (int i = 0; i < length; i++) {
		if (beginchar[i] == 0)
			j++;
		else
			j = 0;

		if (j > 2)
			return;//后面都是0
		else if (j == 0)
			printf("%c", beginchar[i]);
	}
}

void show_gpt_header(struct gpt_header* the_gpt_header) {
	printf("GPT头签名为:");
	for (int i = 0; i < 8; i++)
		printf("%c", the_gpt_header->signature[i]);
	printf("\n");

	printf("版本号为:");
	for (int i = 0; i < 4; i++)
		printf("%0X", the_gpt_header->version[i]);
	printf("\n");

	printf("GPT头大小为 %u 字节\n", uint8to32(the_gpt_header->headersize));

	printf("GPT头CRC校验值为:");
	for (int i = 0; i < 4; i++)
		printf("%0X", the_gpt_header->headercrc32[i]);
	printf("\n");

	printf("GPT表头起始扇区号为 %I64X\n", uint8to64(the_gpt_header->header_lba));
	//备份表头在最后一个EFI扇区，可以得知整个磁盘的大小，扇区数*512/1024/1024/1024
	printf("GPT备份表头扇区号为 %I64X\n", uint8to64(the_gpt_header->backup_lba));

	printf("GPT分区区域的起始扇区号为 %I64X\n", uint8to64(the_gpt_header->pation_first_lba));

	printf("GPT分区区域结束扇区号为 %I64X\n", uint8to64(the_gpt_header->pation_last_lba));

	printf("磁盘GUID为:");
	uint8_t GUID[16];
	changeseqGUID(the_gpt_header->guid, GUID);
	for (int i = 0; i < 16; i++)
	{
		printf("%0X", GUID[i]);
		if (i == 3 || i == 5 || i == 7 || i == 9)
			printf("-");
	}
	printf("\n");

	printf("GPT分区表起始扇区号为 %I64X\n", uint8to64(the_gpt_header->pation_table_first));

	printf("GPT分区表总项数为 %I32X\n", uint8to32(the_gpt_header->pation_table_entries));

	printf("每个分区表占用字节数为 %I32X\n", uint8to32(the_gpt_header->pation_table_size));

	printf("分区表CRC校验值为 %I32X\n", uint8to32(the_gpt_header->pation_table_crc));
}

void showPMBR(struct PMBR*the_pmbr)
{
	printf("引导标志为%X\n", the_pmbr->pation_table_entry[0].bootflag);
	printf("磁头号为%X\n", the_pmbr->pation_table_entry[0].citouhao);
	printf("扇区号为%X\n", the_pmbr->pation_table_entry[0].shanquhao);
	printf("柱面号为%X\n", the_pmbr->pation_table_entry[0].zhumianhao);
	printf("分区类型标志为 %X\n", the_pmbr->pation_table_entry[0].disk_flag);
	printf("第一个扇区为 %u\n", uint8to32(the_pmbr->pation_table_entry[0].relative));
	printf("扇区数为 %u\n", uint8to32(the_pmbr->pation_table_entry[0].sectors));
}

uint8_t show_partition_table(struct partition_table * the_partition_table)
{
	uint8_t GUID[16];
	printf("分区类型值为:");
	uint8_t flag = 0;
	changeseqGUID(the_partition_table->pationtype, GUID);
	for (int i = 0; i < 16; i++)
	{
		flag = flag | GUID[i];
		printf("%0X", GUID[i]);
		if (i == 3 || i == 5 || i == 7 || i == 9)
			printf("-");
	}
	printf("\n");
	for (int i = 0; i < 5; i++) {
		if (compareuint8(GUID, partitiontype[i]))
			printf("***%s***\n", partition_type_info[i]);
	}
	
	printf("分区GUID为:");
	changeseqGUID(the_partition_table->pationid, GUID);
	for (int i = 0; i < 16; i++)
	{
		printf("%0X", GUID[i]);
		if (i == 3 || i == 5 || i == 7 || i == 9)
			printf("-");
	}

	printf("\n该分区起始扇区号为%I64X\n", uint8to64(the_partition_table->pation_start));
	printf("该分区结束扇区号为%I64X\n", uint8to64(the_partition_table->pation_end));
	printf("该分区属性标志为%I64X\n", uint8to64(the_partition_table->pation_attr));
	uint64_t attr = uint8to64(the_partition_table->pation_attr);
	for (int i = 0; i < 6; i++)
	{
		if ((attr&attribute_bits[i])!=0)
			printf("从attributes-bits中可知:%s\n", attribute_bits_info[i]);
	}
	printf("该分区名为:");
	show_partion_name(the_partition_table->pation_name, 72);
	uint64_t bytes = (uint8to64(the_partition_table->pation_end) - uint8to64(the_partition_table->pation_start)) * (uint64_t)512;
	double MB = bytes / 1024.0/1024.0;
	double GB = MB / 1024.0;
	printf("\n该分区大小为%I64X字节，%lf GB",bytes,GB);
	printf("\n\n\n");
	return flag;
}

int read_partition_table(struct gpt_header * the_gpt_header, HANDLE hDevice, ULONGLONG baseaddr)
{

	int entrynum = 0;
	DWORD dwCB;
	LARGE_INTEGER offset;
	partition_table the_partition_tables[4];
	ULONGLONG nextaddr = ((ULONGLONG)0 + (ULONGLONG)baseaddr) *(ULONGLONG)512;
	offset.QuadPart = nextaddr;//找到下一个要读取的地址
	SetFilePointer(hDevice, offset.LowPart, &offset.HighPart, FILE_BEGIN);//设置偏移准备读取
	ReadFile(hDevice, &the_partition_tables, 512, &dwCB, NULL);
	if (GetLastError())
	{
		return 0;
	}
	int endflag = 1;
	int j = 0;//如果j=4，才重新读，因为某种限制，一次必须读512字节整数倍
	while (endflag > 0) {
		printf("\n第%d个分区表:\n", ++entrynum);
		if (j == 4)
		{
			nextaddr = nextaddr + (ULONGLONG)512;
			offset.QuadPart = nextaddr;//找到下一个要读取的地址
			SetFilePointer(hDevice, offset.LowPart, &offset.HighPart, FILE_BEGIN);//设置偏移准备读取
			if (GetLastError())
			{
				return 0;
			}
			memset(&the_partition_tables, 0, 512);
			ReadFile(hDevice, &the_partition_tables, 512, &dwCB, NULL);
			j = 0;
		}
		endflag = show_partition_table(&the_partition_tables[j]);
		j++;
	}
	return 1;
}



int main()
{
	DISK_GEOMETRY pdg;            // 保存磁盘参数的结构体
	HANDLE hDevice;               // 设备句柄
	BOOL bResult;                 // results flag
	DWORD junk;                   // discard resultscc

	int disk = 0;
	const char *diskname[] = { "\\\\.\\PhysicalDrive0" ,"\\\\.\\PhysicalDrive1" };
	printf("请输入要打开的硬盘号(一般为0，有2个硬盘可以输入0或1)\n");
	scanf("%d", &disk);
	if (disk != 0 && disk != 1)
	{
		disk = 0;
		printf("输入无效，打开磁盘0\n");
	}
	//通过CreateFile来获得设备的句柄
	hDevice = CreateFile(diskname[disk], // 设备名称，PhysicalDriveX表示打开第X个设备
		GENERIC_READ,                // no access to the drive
		FILE_SHARE_READ | FILE_SHARE_WRITE,  // share mode
		NULL,             // default security attributes
		OPEN_EXISTING,    // disposition
		0,                // file attributes
		NULL);            // do not copy file attributes
	if (hDevice == INVALID_HANDLE_VALUE) //没能打开，可能是没有用管理员权限运行
	{
		printf("Creatfile error!May be no permission!ERROR_ACCESS_DENIED！\n");
		system("pause");
		return (FALSE);
	}

	//通过DeviceIoControl函数与设备进行IO
	bResult = DeviceIoControl(hDevice, // 设备的句柄
		IOCTL_DISK_GET_DRIVE_GEOMETRY, // 控制码，指明设备的类型
		NULL,
		0, // no input buffer
		&pdg,
		sizeof(pdg),
		&junk,                 // # bytes returned
		(LPOVERLAPPED)NULL); // synchronous I/O

	LARGE_INTEGER offset;//long long signed
	offset.QuadPart = (ULONGLONG)0 * (ULONGLONG)512;//0
	SetFilePointer(hDevice, offset.LowPart, &offset.HighPart, FILE_BEGIN);//从0开始读PMBR
	if (GetLastError())
		printf("错误类型代号：%ld\n\n", GetLastError());//如果出错了

	DWORD dwCB;
	struct PMBR the_pmbr;
	//从这个位置开始读512字节PMBR
	//读取PMBR的512字节，里面的分区表第一项才有用，从1数，第5字节是0xEE
	//相对起始扇区值是GPT Header的位置
	BOOL bRet = ReadFile(hDevice, &the_pmbr, 512, &dwCB, NULL);	
	printf("----------------读取PMBR部分:---------------\n");
	showPMBR(&the_pmbr);
	if (the_pmbr.pation_table_entry[0].disk_flag == 0xEE)//如果的确是GPT格式分区
	{
		printf("PMBR中分区表第一项的标志位为 0xEE，是GPT格式，跳转到%u扇区\n", 
			   uint8to32(the_pmbr.pation_table_entry[0].relative));
		printf("GPT表头在第%u扇区", uint8to32(the_pmbr.pation_table_entry[0].relative));
	}
	else {
		printf("PMBR中分区表第一项标志位为 %X，不是GPT格式，结束分析\n", 
			   the_pmbr.pation_table_entry[0].disk_flag);
		CloseHandle(hDevice);
		system("pause");
		return 0;
	}


	//读取分析GPT Header
	//下一个要读取的线性地址=要读取的扇区号*512字节
	printf("\n\n----------------读取GPT Header部分:---------------\n\n");
	ULONGLONG nextaddr= (ULONGLONG)1*(ULONGLONG)512;
	offset.QuadPart = nextaddr;//找到下一个要读取的地址
	SetFilePointer(hDevice, offset.LowPart, &offset.HighPart, FILE_BEGIN);//设置偏移准备读取
	if (GetLastError())
	{
		printf("读取GPT Header出错。错误类型代号：%ld\n\n", GetLastError());//如果出错了
		CloseHandle(hDevice);
		system("pause");
		return 0;
	}
	//读取GPT Header
	gpt_header the_gpt_header;
	ReadFile(hDevice, &the_gpt_header, 512, &dwCB, NULL);
	show_gpt_header(&the_gpt_header);
	
	//读取主GPT分区表项，分区表项前16个字节如果全0，表示未用，后面都没有了，可以去读备份
	printf("\n\n-------------读取分区表项:-------------\n\n");
	ULONGLONG baseaddr = (ULONGLONG)uint8to64(the_gpt_header.pation_table_first);//GPT分区表起始位置
	if (!read_partition_table(&the_gpt_header, hDevice, baseaddr))//如果出错
	{
		CloseHandle(hDevice);
		system("pause");
		return 0;
	}

	printf("\n\n---------------读取备份的GPT Header:---------------\n\n");
	nextaddr = (ULONGLONG)uint8to32(the_gpt_header.backup_lba)*(ULONGLONG)512;
	offset.QuadPart = nextaddr;//找到下一个要读取的地址
	SetFilePointer(hDevice, offset.LowPart, &offset.HighPart, FILE_BEGIN);//设置偏移准备读取
	if (GetLastError())
	{
		printf("读取备份GPT Header出错。错误类型代号：%ld\n\n", GetLastError());//如果出错了
		CloseHandle(hDevice);
		system("pause");
		return 0;
	}
	//读取备份GPT Header
	gpt_header backup_gpt_header;
	ReadFile(hDevice, &backup_gpt_header, 512, &dwCB, NULL);
	show_gpt_header(&backup_gpt_header);
	
	//读取备份GPT分区表项，分区表项前16个字节如果全0，表示未用，后面都没有了，可以去读备份
	printf("\n\n-------------读取备份分区表项:-------------\n\n");
	baseaddr = (ULONGLONG)uint8to64(backup_gpt_header.pation_table_first);//GPT分区表起始位置
	if (!read_partition_table(&backup_gpt_header, hDevice, baseaddr))//如果出错
	{
		CloseHandle(hDevice);
		system("pause");
		return 0;
	}

	printf("\n\n这块硬盘大小为 %lf GB\n", (double)uint8to64(the_gpt_header.backup_lba) * 512 / 1024 / 1024 / 1024);

	CloseHandle(hDevice);
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410

结果分析

磁盘信息

读取PMBR

读取GPT Header

读取第1个分区表项

第2个分区表项

第3个分区表项

第4个分区表项

备份GPT Header

备份分区表项