C语言读取FAT32分区文件簇链

最新推荐文章于 2024-07-08 11:07:23 发布
最新推荐文章于 2024-07-08 11:07:23 发布
阅读量6.8k 收藏 60
点赞数 10
分类专栏： 软件安全 文章标签： FAT文件系统 FAT32 簇链 文件簇 扇区
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37734256/article/details/88806744
版权

文章目录

FAT32基本结构

  FAT32文件系统由4部分构成：DRB和保留扇区，FAT1，FAT2和数据区。其中数据区中有根目录、子目录和数据三部分。
在这里插入图片描述

DBR的结构

在这里插入图片描述
  开始的3字节是一个跳转指令，指出引导代码的开始位置，EB 58就是跳转到0x58+2(相对于当前位置，当前位置是2)。之后的BPB结构存储了和该分区有关的重要信息。BPB中重要的字段如下：
在这里插入图片描述
  打开磁盘首先进入的是DBR，此时FILE_BEGIN指针为零，是指对DBR的开始位置而言偏移0，保留扇区数的作用是可以通过它，获得FAT 1相对于FILE_BEGIN的偏移。FAT的个数一般是2个，在知道每个FAT占用的扇区数之后，可以通过该字段，获得根目录相对FILE_BEGIN的偏移。根目录的相对开始扇区号=保留扇区数+FAT个数*每个FAT的扇区数。如果要计算绝对地址，则需要用到Hidden Sectors，它指的是该分区DBR之前的扇区数。找文件找簇链，使用相对地址就可以。

目录项的结构

  获得根目录相对扇区号之后，打开到根目录，根目录里面存放着根目录下文件和子目录的目录项，每个项占32字节。
  如果是文件项，该项会指出文件起始簇号和大小。通过起始簇号，找到FAT中对应条目，找到整个文件内容。
  如果是子目录项，该项会指出子目录所在位置，通过子目录项，进入到子目录中，子目录内也是一个个目录项，每个32字节，不过开始的前两个项是“.”和“…”。
  目录项根据文件/子目录的名字长短，分为短目录项和长目录项两种。对于文件名，如果前缀长度小于等于8字节且后缀名小于等于3字节，则它的目录项是短目录项；如果文件前缀大于8字节或者后缀大于3字节，则它的目录项是由1条短目录项和n条长目录项构成。对于子目录名，如果比8字节长，它的目录项就是由1条短目录项和n条长目录项构成，否则只有1条短目录项。

短目录项的重要字段

在这里插入图片描述
  虽然说是短目录项，但是每个文件/子目录，都至少有1个短目录项，里面最重要的字段是起始簇号，如果是文件，在FAT表中通过起始簇号，可以找到文件内容；如果是子目录，通过它可以跳转到子目录中。名字太长的文件和子目录，也会有1个短目录项，这其中的前11个字节没有实质性意义，前8个字节中的文件名是文件头6字节的文件名大写+’~1’，而簇号是有意义的，虽然是长文件名的文件或目录，它的起始簇号，是存在这一个短目录项中的，长目录项项中的这一字段往往置0。
  如果文件前缀名太短，比8字节还短，或者后缀比3字节短，在对应字段中，是会用0x20进行填充，而不是0x00。在检索进行文件比较的时候，需要注意该填充。长目录项中的填充方法则与这个不同。
  短目录项的0x0B属性字段占1个字节，这8位，置位不同位有不同的含义。短目录项的这一位绝对不会是0x0F，因为0x0F对应着的是长目录项，通过这一位来判断目录项是短目录项还是长目录项：
在这里插入图片描述

长目录项重要字段

在这里插入图片描述
  长目录项的0x0B字段一定是0x0F。长目录项的作用是存储文件名。①②③按照Unicode编码方式存储文件名，在一个长文件目录项中，文件名是按照①②③的顺序拼接的。可能会有这种情况：长文件名在①或者②中就正好够了，那么剩下没有用到的字段，会首先填充一个0x00，Unicode下，0x00后面还会接着一个0x00，之后填充0xFF。在拼接长文件名时，可以完全复制，两个连续的0x00作为字符串截断，虽然之后有0xFF，但是不影响字符串比较。
  第1字节属性字节，低5位置位含义如下：
在这里插入图片描述
  对于一个长文件名的文件或者目录，序号的含义是，从高地址往低地址走，会经过1个短目录项和n个长目录项，序号值从1开始，每经过一个长目录项，该值加1。走到最后一个长目录项，第6位会置位1，如下面的图中所示，最后一个长目录项的该位为0x42，含义是这是第2个长目录项，且是最后一个长目录项。
 &emsp一个文件或子目录的名字比较长，它的前6字节会出现在短目录项中，接着，完整的包括那6字节的文件名可以在长目录项中找到。存储顺序是文件名1+文件名2，内部按照①②③的顺序，如下图所示：
在这里插入图片描述

FAT表项

  FAT像一个巨大的链表，每个表项4字节。在目录中找到一个文件的开始簇号，来查FAT表，找到这个簇号对应的FAT表项。如果该表项是0x0FFFFFFF，表示是该文件的最后一簇，否则该表项指向的是该文件占用的下一个簇号。

解析文件路径(英文路径)

路径：E/testdir1/longlonglongsubdir/nothing.txt

  1. 首先，读出E，打开文件到达E分区的DBR。
  2. 解析路径：testdir1只有8字节，在根目录中对应1条短目录项； longlonglongsubdir超长了，对应1条短目录项+n条长目录项；nothing.txt超长了，对应1条短目录项+n条长目录项。
  3. 进入根目录，顺序寻找testdir1这个短目录项，如果读到的目录项的第1个字节是0x00，表明读到了未用的目录项，还没有找到，则路径错误。
  4. 进入testdir1目录，寻找longlonglongsubdir，方法是先找短目录项，比对前6个字节，如果相同，再倒回去把长目录项中的文件名拼接好，和longlonglongsubdir进行比对，如果相同，则说明找到。如果读到的目录项的第1个字节是0x00，表明读到了未用的目录项，还没有找到，则路径错误。
  5. 进入到longlonglongsubdir，寻找nothing.txt，也是先比较前6个字节是否相同，再拼接文件名比对。如果找到了，获得nothing.txt的起始簇号。
  6. 在FAT中，找到文件起始簇号对应的条目，如果是0x0FFFFFFF，则已经到达文件的最后一簇，否则该条目表示的是文件占用的下一个簇号，进行遍历。

源代码

#include <windows.h>
#include <winioctl.h> //DDK驱动开发与控制
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <stdint.h>
#include <cstring>
#define onesector 512 //扇区512 

uint8_t lpBuffer[onesector] = { 0 };//用于读512字节 
uint8_t lpBuffer2[onesector] = { 0 };//用于临时读512字节 
//DBR结构，EBR应该也是类似管理 
struct DBR {
	uint8_t jumpcode[3];//EB 58 90
	uint8_t OEM[8];//OEM代号
	uint8_t bytes_per_sector[2];//扇区字节数
	uint8_t secotrs_per_cluster;//每簇扇区数
	uint8_t reserve_sectors[2];//包括DBR自己在内的FAT之前的扇区个数
	uint8_t FATnum;//FAT个数，一般为2 
	uint8_t unimportant1[11];
	uint8_t DBR_LBA[4];//该分区的DBR所在的相对扇区号，如果是扩展分区，是相对于扩展分区首的
	uint8_t totalsectors[4];//本分区的总扇区数
	uint8_t sectors_per_FAT[4];//每个FAT的扇区数
	uint8_t unimportant2[4];
	uint8_t root_cluster_number[4];//根目录簇号
	uint8_t file_info[2];
	uint8_t backup_DBR[2];//备份引导扇区的相对于DBR的扇区号，一般为6，内容和DBR一模一样
	uint8_t zero1[12];
	uint8_t extBPB[26];//扩展BPB
	uint8_t osboot[422];//引导代码和55AA 
};

struct FDT {
	char content[32];
};

//短文件目录项32字节
struct shortFDT {
	uint8_t filename[8];//第一部分文件名
	uint8_t extname[3];//文件扩展名
	uint8_t attr;//属性 0F则说明是长文件需要索引到非0F，然后倒着读回来
	uint8_t reserve;
	uint8_t time1;
	uint8_t creattime[2];
	uint8_t createdate[2];
	uint8_t visittime[2];
	uint8_t high_cluster[2];//文件起始簇号高16位
	uint8_t changetim2[2];
	uint8_t changedate[2];
	uint8_t low_cluster[2];//文件起始簇号低16位
	uint8_t filelen[4];//文件长度
};

struct longFDT {
	char flag;//如果是0x4*,第6位置位了，说明是最后一个长文件目录，各位是下面还有几个
	char name1[10];
	char attr;//如果是长文件名，除了最下面一个，都是0F
	char reserve;
	char checksum;
	char name2[12];
	char rel_cluster[2];//相对起始簇号
	char name3[4];
};

//文件名可能很长，方便检索文件名
struct long_FDT_list {
	struct longFDT lfdt;
	struct long_FDT_list * up;//上面的（低地址）
	struct long_FDT_list * down;
};

struct findfilepath {
	char prename[100];
	char rearname[10];
	int flag;//1是短文件，2是长文件，3是短目录，4是长目录;是3/4则next非空
	struct findfilepath *next;
};


uint16_t uint8to16(uint8_t twouint8[2]) {
	return *(uint16_t*)twouint8;
}

uint32_t uint8to32(uint8_t fouruint8[4]) {
	return *(uint32_t*)fouruint8;
}

uint64_t uint8to64(uint8_t eightuint8[8]) {
	return *(uint64_t*)eightuint8;
}

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;
}

int comparestr(char * a, char *b)
{
	if (strlen(a) != strlen(b))
		return 0;
	for (int i = 0; i < strlen(a); i++)
	{
		if (a[i] != b[i])
			return 0;
	}
	return 1;
}

int compare_nobs_str(char * a, char *b)
{
	if (strlen(a) != strlen(b))
		return 0;
	for (int i = 0; i < strlen(a); i++)
	{
		if (a[i] != b[i] || toupper(a[i]) != toupper(b[i]))//大小写不敏感
			return 0;
	}
	return 1;
}

void show_onesector(uint8_t sector[onesector])
{
	for (int i = 0; i < onesector; i++)
	{
		if (sector[i] < 16)
			printf("0%X ", sector[i]);
		else
			printf("%X ", sector[i]);
		if ((i + 1) % 16 == 0)
			printf("\n");
	}
}

//第一步，寻找分区
int whichpartition(char partition_char) {
	int partition = -1;
	switch (partition_char) {
	case 'C':
	case 'c':
		partition = 0;
		break;
	case 'D':
	case 'd':
		partition = 1;
		break;
	case 'E':
	case 'e':
		partition = 2;
		break;
	case 'F':
	case 'f':
		partition = 3;
		break;
	case 'G':
	case 'g':
		partition = 4;
		break;
	case 'H':
	case 'h':
		partition = 5;
		break;
	case 'I':
	case 'i':
		partition = 6;
		break;
	case 'J':
	case 'j':
		partition = 7;
		break;
	default:
		partition = -1;
		break;
	}
	return partition;
}

//简单的英文的两个转一个,不会出现两个连续的00，出现就表示已经到结尾了
//文件不区分大小写的，全部toupper，记得那个'.'！！！！是存在里面的!!!!把读出来的点删掉
void double2single(char *filename, char *upperfilename, int num) {
	int j = 0;
	for (int i = 0; i < num; i = i + 2)
	{    //如果是字母，返回非零，否则返回零！！！
		if (isalpha(filename[i]) == 0)
		{
			upperfilename[j] = filename[i];
		}
		else
			upperfilename[j] = toupper(filename[i]);
		j++;
	}
}
//文件不区分大小写的，全部toupper
void short2upper(char*filename) {
	for (int i = 0; i < strlen(filename); i++)
		filename[i] = toupper(filename[i]);
}

//下一步解析，如果已经到了文件尾，这次解析出的是文件名，那么返回0[[后面没有斜杠了'/']
//否则还要再次调用解析，是目录返回1[后面还有一个斜杠]
//否则出错，返回-1
//如果返回1，或者0，下一次的目录/文件名，保存在nextname里面[由调用者维护，不检查长度]
//indexptr是用来保存当前检索到了哪里，下一次直接继续[调用者维护]
int nextpath(char *filepath, char *nextname, int *indexptr) {
	int flag = -1;
	int firstindex = 0, lastindex = 0;
	int filepathlen = strlen(filepath);
	short2upper(filepath);
	if (*indexptr >= filepathlen)//6个空间，索引最大为5
		return -1;
	//解析文件名
	while (1) {
		//判断是否结束或者出错
		if (*indexptr >= filepathlen && flag == -1)//如果出错
		{
			flag = -1;//出错了
			break;
		}
		else if (*indexptr == filepathlen && flag == 1) {
			flag = 0;//读完了,假设到文件了
			break;
		}

		if (filepath[*indexptr] == ':')//如果在一开始是冒号,往后读内容
		{
			;
		}
		if (filepath[*indexptr] == '/' && flag == -1)//如果是第一个反斜杠,标志开始
		{
			if ((*indexptr) + 1 < filepathlen) {
				firstindex = (*indexptr) + 1;
				//printf("firstindex = %d\n",firstindex);
				flag = 1;//暂时等于1
			}
			else {
				flag = -1; break;//出错了
			}
		}
		else if (filepath[*indexptr] == '/' && flag != -1)//解析完一个了
		{
			lastindex = (*indexptr) - 1;//收尾了
			//printf("lastindex = %d\n",lastindex);
			break;
		}
		(*indexptr)++;
	}
	if (flag != -1)
	{
		memset(nextname, 0, sizeof(nextname));
		if (flag == 1)//目录
			strncpy(nextname, &filepath[firstindex], lastindex - firstindex + 1);//复制字符串
		else
			strncpy(nextname, &filepath[firstindex], filepathlen - firstindex);//复制字符串
		//printf("next name=%s\n",nextname);
	}
	return flag;
}

//把文件名存放为文件名和后缀名，后缀名大于3的，也都是用长文件名格式;含有空格的也都是长文件名
int dividefilename(char*filename, char*prename, char*rearname) {
	//printf("dividename is %s %d\n",filename,strlen(filename));
	int dotindex = 0;
	for (int i = 0; i < strlen(filename); i++) {
		if (filename[i] == '.')//找到分界了
		{
			dotindex = i;
			//printf("dotindex = %d\n",dotindex);
			break;//假设输入是对的
		}
	}
	if (dotindex == 0)
		return -1;
	strncpy(prename, filename, dotindex);//复制前面文件名
	strncpy(rearname, &filename[dotindex + 1], strlen(filename) - dotindex - 1);
	//printf("copy filename: %s   %s  strlen=%d  %d\n",prename,rearname,strlen(prename),strlen(rearname));

	return 0;
}

void getpathlist(char*filepath, struct findfilepath*&head, int *filenameindex) {
	struct findfilepath *p = NULL, *rear = NULL;
	int t;//有木有结束
	char nextname[100];
	char prename[100];
	char rearname[10];
	int padding = 0;
	char paddingnum = 0x20;
	while (1) {
		memset(nextname, 0, sizeof(nextname));
		memset(prename, 0, sizeof(prename));
		memset(rearname, 0, sizeof(rearname));
		t = nextpath(filepath, nextname, filenameindex);
		if (t != -1)//正常情况是得到目录名
		{
			if (t == 1)//目录名
			{
				printf("目录为%s  长度为%d\n", nextname, strlen(nextname));
				p = (struct findfilepath*)malloc(sizeof(struct findfilepath));
				p->next = NULL;
				memset(p->prename, 0, sizeof(p->prename));
				memset(p->rearname, 0, sizeof(p->rearname));

				if (strlen(nextname) > 8)//需要长文件存
				{
					p->flag = 4;//长目录
					strncpy(p->prename, nextname, strlen(nextname));//长目录直接存
					//printf("长目录 %s %d\n",p->prename,strlen(p->prename));
				}
				else
				{
					p->flag = 3;//短目录
					strncpy(p->prename, nextname, strlen(nextname));//短目录补0x20
					paddingnum = 8 - strlen(p->prename);
					if (paddingnum > 0)
						memset(&p->prename[strlen(p->prename)], 0x20, paddingnum);
					//printf("短目录 %s %d\n",p->prename,strlen(p->prename));
				}
				if (rear == NULL)
				{
					head = p; rear = p;
				}
				else
				{
					rear->next = p; rear = p;
				}
			}
			else//t==0，是文件名
			{
				printf("文件为%s  长度为%d\n", nextname, strlen(nextname));
				p = (struct findfilepath*)malloc(sizeof(struct findfilepath));
				p->next = NULL;

				memset(p->prename, 0, strlen(p->prename));
				memset(p->rearname, 0, strlen(p->rearname));
				dividefilename(nextname, prename, rearname);
				if (strlen(prename) > 8 || strlen(rearname) > 3)//需要长文件存
				{
					p->flag = 2;//长文件
					strncpy(p->prename, prename, strlen(prename));
					strncpy(p->rearname, rearname, strlen(rearname));
					//printf("长文件 %s.%s\n",p->prename,p->rearname);
				}
				else
				{
					p->flag = 1;//短文件
					strncpy(p->prename, prename, strlen(prename));
					paddingnum = 8 - strlen(p->prename);
					if (paddingnum > 0)
						memset(&p->prename[strlen(p->prename)], 0x20, paddingnum);

					strncpy(p->rearname, rearname, strlen(rearname));
					paddingnum = 3 - strlen(p->rearname);
					if (paddingnum > 0)
						memset(&p->rearname[strlen(p->rearname)], 0x20, paddingnum);
					//printf("短文件 %s.%s\n",p->prename,p->rearname);
				}
				if (rear == NULL)
				{
					head = p; rear = p;
				}
				else
				{
					rear->next = p; rear = p;
				}
			}
		}
		else
			break;
	}
}


//解析短文件名
void readshortfileFDT(struct shortFDT the_short_FDT, ULONGLONG FAT1_reladdr, HANDLE hDevice) {
	uint8_t cluster[4] = { the_short_FDT.low_cluster[0],the_short_FDT.low_cluster[1],
						the_short_FDT.high_cluster[0],the_short_FDT.high_cluster[1] };
	uint32_t firstcluster = uint8to32(cluster);//起始簇号
	printf("文件开始簇号是%08X\n", firstcluster);
	printf("簇链:\n%08X\n", firstcluster);
	int next_sector = firstcluster / 128;//在第几个扇区？512*beg_sector
	int next_byte = (firstcluster % 128) * 4;
	uint32_t FATentry = 0;
	uint8_t Buffer[512] = { 0 };
	int needreadmore = 1;
	int seqindex = 0;
	BOOL bRet;
	DWORD dwCB;

	LARGE_INTEGER offset;
	offset.QuadPart = FAT1_reladdr + (ULONGLONG)(512 * next_sector);
	SetFilePointer(hDevice, offset.LowPart, &offset.HighPart, FILE_BEGIN);
	bRet = ReadFile(hDevice, Buffer, 512, &dwCB, NULL);

	while (needreadmore == 1) {
		FATentry = *(uint32_t*)&Buffer[next_byte];
		printf("%08X\n", FATentry);
		if (FATentry != 0x0FFFFFFF)//尚未结束
		{
			if (next_sector != FATentry / 128)
			{
				next_sector = FATentry / 128;
				offset.QuadPart = FAT1_reladdr + (ULONGLONG)(512 * next_sector);
				SetFilePointer(hDevice, offset.LowPart, &offset.HighPart, FILE_BEGIN);
				memset(Buffer, 0, 512);
				bRet = ReadFile(hDevice, Buffer, 512, &dwCB, NULL);
			}
			next_byte = (FATentry % 128) * 4;
		}
		else
			needreadmore = 0;
	}
}

//解析短目录名，通过相对于根目录，找到绝对地址
ULONGLONG readshortdirFDT(struct shortFDT the_short_FDT, ULONGLONG root_reladdr, HANDLE hDevice, int secotrs_per_cluster) {
	uint8_t cluster[4] = { the_short_FDT.low_cluster[0],the_short_FDT.low_cluster[1],
						the_short_FDT.high_cluster[0],the_short_FDT.high_cluster[1] };
	uint32_t firstcluster = uint8to32(cluster);//起始簇号
	printf("目录开始簇号是%08X\n", firstcluster);
	ULONGLONG nextaddr = (ULONGLONG)((firstcluster - 2)*secotrs_per_cluster * 512) + root_reladdr;
	return nextaddr;
}

void findfile(struct findfilepath * head, char* partition) {
	struct findfilepath *p = NULL;

	DISK_GEOMETRY *pdg;            // 保存磁盘参数的结构体
	BOOL bResult;                 // generic results flag
	ULONGLONG DiskSize;           // size of the drive, in bytes
	HANDLE hDevice;               // 设备句柄
	DWORD junk;                   // discard resultscc
	//通过CreateFile来获得设备的句柄，打开对应的盘 
	hDevice = CreateFile(TEXT(partition), // 设备名称,这里指硬盘甚至可以是分区/扩展分区名，不区分大小写 
		GENERIC_READ,                // 读
		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) // cannot open the drive
	{
		printf("May be no permission!Or no such partition!\n");
		return;
	}

	//通过DeviceIoControl函数与设备进行IO，为后面做准备 
	bResult = DeviceIoControl(hDevice, // 设备的句柄
		IOCTL_DISK_GET_DRIVE_GEOMETRY, // 控制码，指明设备的类型
		NULL, 0, // no input buffer
		pdg,
		sizeof(*pdg),     // output buffer 输出，保存磁盘参数信息
		&junk,                 // # bytes returned
		(LPOVERLAPPED)NULL); // synchronous I/O

	LARGE_INTEGER offset;//读取位置 
	offset.QuadPart = (ULONGLONG)0;//0
	SetFilePointer(hDevice, offset.LowPart, &offset.HighPart, FILE_BEGIN);//从这个位置开始读，DBR是FILE_BEGIN，相对位移！！！ 

	DWORD dwCB;
	struct DBR the_DBR;
	//从这个位置开始读DBR，一开始的512字节有些信息有用 
	BOOL bRet = ReadFile(hDevice, &the_DBR, 512, &dwCB, NULL);
	ULONGLONG FAT1_reladdr = (ULONGLONG)uint8to16(the_DBR.reserve_sectors) *
		(ULONGLONG)512;//得到FAT1的具体地址，但是偏移需要用相对偏移 

	ULONGLONG root_reladdr = FAT1_reladdr + (ULONGLONG)(the_DBR.FATnum) *
		(ULONGLONG)uint8to32(the_DBR.sectors_per_FAT)*(ULONGLONG)512;//根目录的起始相对位置,根目录是在第[01]2簇

	offset.QuadPart = root_reladdr;
	SetFilePointer(hDevice, offset.LowPart, &offset.HighPart, FILE_BEGIN);
	memset(lpBuffer, 0, sizeof(lpBuffer));
	bRet = ReadFile(hDevice, lpBuffer, 512, &dwCB, NULL);
	//show_onesector(lpBuffer);

	char prename[101] = { 0 };
	char rearname[10] = { 0 };
	int needreadmore = 0;//在这一层目录需要继续读扇区，还没有找到文件/恰好被长文件分割了

	//1次只能读512字节整数倍,16个FDT,每个32字节
	struct FDT tempFDT[16] = { 0 }, temp_tempFDT[16] = { 0 };//后面的给长目录和文件准备
	struct shortFDT the_short_FDT = { 0 };
	struct longFDT the_long_FDT[10];
	int longfdtindex = 0;//索引项
	int index = 0;
	int tempindex = 0;
	LARGE_INTEGER temp_offset;//临时倒退找长文件项的
	int findflag = 0, mayfindflag = 0;
	p = head;
	int i = 0;
	while (p != NULL)//还没有找到，一层层找
	{
		memset(tempFDT, 0, sizeof(tempFDT));
		memcpy(tempFDT, lpBuffer, 512);
		if (p->next == NULL && (p->flag == 1 || p->flag == 2))//如果在这一层是文件
		{
			if (p->flag == 1)//是短文件,找到以后可以用短文件解析
			{
				findflag = 0; index = 0;
				while (findflag == 0) {
					if (tempFDT[index].content[0] == 0x00) {
						printf("\n路径错误!\n");
						return;
					}
					if (tempFDT[index].content[11] != 0x0F)
					{
						memset(prename, 0, sizeof(prename));
						memset(rearname, 0, sizeof(rearname));
						strncpy(prename, &tempFDT[index].content[0], 8);
						strncpy(rearname, &tempFDT[index].content[8], 3);
						if (!strcmp(prename, p->prename) && !strcmp(rearname, p->rearname))
						{
							findflag = 1;
							memcpy(&the_short_FDT, &tempFDT[index], 32);
							readshortfileFDT(the_short_FDT, FAT1_reladdr, hDevice);
						}
					}
					if (index < 15 && findflag == 0)//没找到
						index++;
					else if (index == 15 && findflag == 0)
					{
						index = 0;
						memset(tempFDT, 0, sizeof(tempFDT));
						memset(lpBuffer, 0, sizeof(lpBuffer));
						offset.QuadPart = offset.QuadPart + (ULONGLONG)512;
						SetFilePointer(hDevice, offset.LowPart, &offset.HighPart, FILE_BEGIN);
						bRet = ReadFile(hDevice, lpBuffer, 512, &dwCB, NULL);
						memcpy(tempFDT, lpBuffer, 512);
					}
				}
			}
			else if (p->flag == 2)
			{
				while (findflag == 0) {
					if (tempFDT[index].content[0] == 0x00) {
						printf("\n路径错误!\n");
						return;
					}
					if ((tempFDT[index].content[11] & 0x10) == 0)//文件项,先找找文件名头四个对不对
					{
						memset(prename, 0, sizeof(prename));
						memcpy(prename, &tempFDT[index].content[0], 8);
						if (!strnicmp(prename, p->prename, 4))
						{
							memset(&the_short_FDT, 0, 32);
							memcpy(&the_short_FDT, &tempFDT[index], 32);//里面存着长目录的地址信息
							tempindex = index;//不能影响环境！！！！
							memset(prename, 0, sizeof(prename));
							memcpy(temp_tempFDT, tempFDT, sizeof(tempFDT));
							while (1) {
								if (tempindex > 0)//如果暂时不需要倒退
								{
									tempindex--;
									if (temp_tempFDT[tempindex].content[11] == 0x0F)//的确没完
									{
										memset(&the_long_FDT[longfdtindex], 0, 32);
										memcpy(&the_long_FDT[longfdtindex], &temp_tempFDT[tempindex], 32);
										longfdtindex++;//下一个索引
									}
									else//读完了，处理字符串
									{
										for (int i = 0, k = 0; i < longfdtindex; i++)
										{
											for (int j = 0; j < 3; j++)//复制三部分
											{
												if (j == 0) {
													double2single(the_long_FDT[i].name1,
														&prename[k], 10);
													k = k + 5;
												}
												else if (j == 1) {
													double2single(the_long_FDT[i].name2,
														&prename[k], 12);
													k = k + 6;
												}
												else {
													double2single(the_long_FDT[i].name3,
														&prename[k], 4);
													k = k + 2;
												}

											}
										}
										//printf("文件名是  %s.%s\n", p->prename, p->rearname);
										//printf("拼的文件名是  %s\n", prename);
										if (!strnicmp(prename, p->prename, strlen(p->prename)) &&
											!strnicmp(prename + strlen(p->prename) + 1, p->rearname,
												strlen(p->rearname)))
										{
											findflag = 1;
											goto findlongname;
										}
										else
										{
											findflag = 0;
											goto noyet;
										}
									}
								}
								else {//倒退回去，继续读
									tempindex = 16;//后面一进入就要做一次减法
									memset(temp_tempFDT, 0, sizeof(temp_tempFDT));
									memset(lpBuffer, 0, sizeof(lpBuffer));
									temp_offset.QuadPart = offset.QuadPart - (ULONGLONG)512;
									SetFilePointer(hDevice, temp_offset.LowPart, &temp_offset.HighPart, FILE_BEGIN);
									bRet = ReadFile(hDevice, lpBuffer, 512, &dwCB, NULL);
									memcpy(temp_tempFDT, lpBuffer, 512);
								}
							}	//end of while(1) 找长文件名目录项
						}//end of if 文件前四个相同
					noyet://这个不是，虽然文件名前四个相同
						longfdtindex = 0;
					findlongname://是的，找到了
						if (findflag == 1)
							readshortfileFDT(the_short_FDT, FAT1_reladdr, hDevice);

					}//end of if 如果是一个短文件目录项
					if (index < 15 && findflag == 0)//没找到
						index++;
					else if (index == 15 && findflag == 0)
					{
						index = 0;
						memset(tempFDT, 0, sizeof(tempFDT));
						memset(lpBuffer, 0, sizeof(lpBuffer));
						offset.QuadPart = offset.QuadPart + (ULONGLONG)512;
						SetFilePointer(hDevice, offset.LowPart, &offset.HighPart, FILE_BEGIN);
						bRet = ReadFile(hDevice, lpBuffer, 512, &dwCB, NULL);
						memcpy(tempFDT, lpBuffer, 512);
					}
				}//end of while(findflag=0)	已经找到了，调出来
			}//长文件，不用读了
		}
		else if (p->next != NULL && (p->flag == 3 || p->flag == 4))
		{

			if (p->flag == 3)//如果是短目录
			{
				findflag = 0; index = 0;
				i = 0;
				while (findflag == 0) {
					if (tempFDT[index].content[0] == 0x00) {
						printf("\n路径错误!\n");
						return;
					}
					//注意运算符顺序
					if ((tempFDT[index].content[11] & 0x10) != 0)//短目录项
					{	
						memset(prename, 0, sizeof(prename));
						memcpy(prename, &tempFDT[index].content[0], 8);
						if (!strcmp(prename, p->prename))
						{
							findflag = 1;
							memset(&the_short_FDT, 0, 32);
							memcpy(&the_short_FDT, &tempFDT[index], 32);
							//更新
							offset.QuadPart = readshortdirFDT(the_short_FDT, root_reladdr,
								hDevice, the_DBR.secotrs_per_cluster);
						}
					}
					if (index < 15 && findflag == 0)//没找到
						index++;
					else if (index == 15 && findflag == 0)
					{
						index = 0;
						memset(tempFDT, 0, sizeof(tempFDT));
						memset(lpBuffer, 0, sizeof(lpBuffer));
						offset.QuadPart = offset.QuadPart + (ULONGLONG)512;
						SetFilePointer(hDevice, offset.LowPart, &offset.HighPart, FILE_BEGIN);
						bRet = ReadFile(hDevice, lpBuffer, 512, &dwCB, NULL);
					}
				}
			}
			else if (p->flag == 4)//长目录，有点难受！！！,不如先找头4个字节！！！，大写的
			{
				
				while (findflag == 0) {
					if (tempFDT[index].content[0] == 0x00) {
						printf("\n路径错误!\n");
						return;
					}
					if ((tempFDT[index].content[11] & 0x10) != 0)//目录项，先找找文件名头四个对不对
					{
						memset(prename, 0, sizeof(prename));
						memcpy(prename, &tempFDT[index].content[0], 8);
						if (!strnicmp(prename, p->prename, 4))
						{
							memset(&the_short_FDT, 0, 32);
							memcpy(&the_short_FDT, &tempFDT[index], 32);//里面存着长目录的地址信息
							tempindex = index;//不能影响环境！！！！
							memset(prename, 0, sizeof(prename));
							memcpy(temp_tempFDT, tempFDT, sizeof(tempFDT));
							while (1) {
								if (tempindex > 0)//如果暂时不需要倒退
								{
									tempindex--;
									if (temp_tempFDT[tempindex].content[11] == 0x0F)//的确没完
									{
										memset(&the_long_FDT[longfdtindex], 0, 32);
										memcpy(&the_long_FDT[longfdtindex], &temp_tempFDT[tempindex], 32);
										longfdtindex++;//下一个索引
									}
									else//读完了，处理字符串
									{
										for (int i = 0, k = 0; i < longfdtindex; i++)
										{
											for (int j = 0; j < 3; j++)//复制三部分
											{
												if (j == 0) {
													double2single(the_long_FDT[i].name1,
														&prename[k], 10);
													k = k + 5;
												}
												else if (j == 1) {
													double2single(the_long_FDT[i].name2,
														&prename[k], 12);
													k = k + 6;
												}
												else {
													double2single(the_long_FDT[i].name3,
														&prename[k], 4);
													k = k + 2;
												}
											}
										}
										//printf("文件目录是  %s\n", p->prename);
										//printf("拼的目录是  %s\n", prename);
										if (!strcmp(prename, p->prename))
										{
											findflag = 1;
											goto finddir;
										}
										else
										{
											findflag = 0;
											goto notyet;
										}
									}
								}
								else {//倒退回去，继续读
									tempindex = 16;//后面一进入就要做一次减法
									memset(temp_tempFDT, 0, sizeof(temp_tempFDT));
									memset(lpBuffer, 0, sizeof(lpBuffer));
									temp_offset.QuadPart = offset.QuadPart - (ULONGLONG)512;
									SetFilePointer(hDevice, temp_offset.LowPart, &temp_offset.HighPart, FILE_BEGIN);
									bRet = ReadFile(hDevice, lpBuffer, 512, &dwCB, NULL);
									memcpy(temp_tempFDT, lpBuffer, 512);
								}
							}
						}//end of while(1) 找长文件名目录项
					notyet://这个不是，虽然文件名前四个相同
						longfdtindex = 0;
					finddir://是的，找到了
						if (findflag == 1)
							offset.QuadPart = readshortdirFDT(the_short_FDT, root_reladdr,
								hDevice, the_DBR.secotrs_per_cluster);

					}//end of if 如果是一个短文件目录项
					if (index < 15 && findflag == 0)//没找到
						index++;
					else if (index == 15 && findflag == 0)
					{
						index = 0;
						memset(tempFDT, 0, sizeof(tempFDT));
						memset(lpBuffer, 0, sizeof(lpBuffer));
						offset.QuadPart = offset.QuadPart + (ULONGLONG)512;
						SetFilePointer(hDevice, offset.LowPart, &offset.HighPart, FILE_BEGIN);
						bRet = ReadFile(hDevice, lpBuffer, 512, &dwCB, NULL);
						memcpy(tempFDT, lpBuffer, 512);
					}
				}//end of while(findflag=0)	已经找到了，调出来
			}//end of if 如果是当前解析的是长文件目录

			//!!!是目录，继续读下一步扇区!!!在上面复制回来
			memset(tempFDT, 0, sizeof(tempFDT));
			memset(lpBuffer, 0, sizeof(lpBuffer));
			SetFilePointer(hDevice, offset.LowPart, &offset.HighPart, FILE_BEGIN);
			bRet = ReadFile(hDevice, lpBuffer, 512, &dwCB, NULL);
			memcpy(tempFDT, lpBuffer, 512);
		}
		findflag = 0;
		p = p->next;//下一层路径
	}
	CloseHandle(hDevice);//如果打开成功，需要关闭 
}

void freepathlist(struct findfilepath *&head) {
	struct findfilepath *p = NULL;
	p = head;
	while (p != NULL) {
		p = p->next;
		free(p);
	}
}

int main()
{
	DISK_GEOMETRY pdg;            // 保存磁盘参数的结构体
	BOOL bResult;                 // generic results flag
	ULONGLONG DiskSize;           // size of the drive, in bytes
	printf("请输入文件路径:[假设输入是对的，注意斜杠方向，如E:/testdir/hello.txt]\n");
	char filepath[101] = { 0 };//文件名可能很长，方便检索文件名
	gets(filepath);
	struct findfilepath *p = NULL, *head = NULL;
	char partition[]="\\\\.\\C:";
	partition[4]=filepath[0];
	int filenameindex = 1;//从1开始解析

	//指针s要用引用类型，不然是副本，内存泄漏
	getpathlist(filepath, head, &filenameindex);
	findfile(head, partition);

	freepathlist(head);
	system("pause");
	return 0;
}

验证

长文件名/目录名

  在FAT32分区格式，E:/testdir1/longlonglongsubdir/nothing.txt文件。testdir1是8字节，短目录项，而longlonglongsubdir和nothing.txt都要用到长目录项。
在这里插入图片描述
在这里插入图片描述
  分析结果，文件路径解析正确，testdir1的开始簇号是0x3号，longlonglongsubdir的开始簇号是0x5A2号,nothing.txt文件的开始簇号是0x5A3号。
  打开winHex验证结果，E盘的根目录开始地址是0x4FF99E200，里面存放着包括testdir1在内的内容，找到该条目，高位簇号为0，低位为0x0003。
在这里插入图片描述
  根目录是2号簇，地址0x4FF99E200，在此基础上加上0x1000得到3号簇，也就是0x4FF99F200处，找到的确有longlonglongsubdir一项，该项所在簇号为0x5A2，相对于根目录偏移0x5A0个簇，也就是5A0000个字节偏移。
在这里插入图片描述
  打开到这，在longlonglongsubdir中，的确看到有nothing.txt的条目，是1个短目录项，开始簇号为5A3。
在这里插入图片描述
  继续找到FAT1中，寻找簇号为0x5A3的条目。FAT1的起始地址是0x4FF1A2A00，每个条目4字节，0x5A3在FAT中的起始偏移地址是0x1688，该项目是0x0FFFFFFF，是该文件的最后一簇。
在这里插入图片描述

占多个簇

在这里插入图片描述
继续在FAT中寻找，找到0x5A5对应的条目，与打印出来的是一致的：
在这里插入图片描述

后续需要考虑的

  在上面，是假设目录区，无论是根目录还是子目录中的目录项，都是小于128项的，都在一个簇内。如果根目录中多于128项，而且根目录后3号簇很可能被占用了，根目录的下一簇应该需要在FAT表中查找，如果文件名/目录名很长，不仅跨扇区了（代码中考虑了跨扇区的情况，回溯，能够拼出文件名），还跨簇了，这种情况代码中没有考虑。
  上面长文件名拼接时，用大小为10的数组存储长目录项而不是链表或者更大数组，如果长目录项超过10个，就会出现问题。
  暂时没有考虑中文的因素，所以在处理文件名的时候比较简单粗暴，短文件名直接变成大写进行比对，长文件名两个两个字节读取，取第一个字节。实际在处理的时候，应该考虑Unicode编码的问题，windows的FAT32中，长文件名的Unicode编码是UTF-16LE，需要使用到MultiByteToWideChar()函数和WideCharToMultiByte()函数进行转换处理。

参考链接

详解FAT32文件系统
http://www.blogfshare.com/detail-fat32-filesys.html
这位博主tql，很多文章都写得非常非常非常地好，而且是正确的！

威化饼的一隅
关注
  • 10
    点赞
  • 踩
  • 60
    收藏
    觉得还不错? 一键收藏
  • 16
    评论
专栏目录
C51上的FAT32文件系统参考源代码
11-22
C51上的FAT32系统，可以作为单片机驱动SD卡等类似的文件系统参考
VC++读写FAT32操作
05-29
VC6.0及以上版本 读写扇区(以字节或字读取) 读写簇(以字节或字读取) 读取FAT项 获取BPB信息 获取某文件或文件夹的目录项信息(入口簇及偏移量)
文件系统入门：什么是簇、簇的大小如何选择
最新发布
weixin_44126836的博客
07-08 1217
簇是文件系统中磁盘空间的分配单元。文件数据按照簇的大小被分割并存储在磁盘上。
循环检测U盘并复制所有文件
HECSON的博客
12-06 315
#include <windows.h> void main(){ while(1){ char DiskName[256]="H:\\"; UINT DiskType; unsigned char i = 0x42; // 42为大写字母B // 遍历盘符 for(; i < 0x5B; i += 0x1){ // 5A为大写字母Z, 5B为中括号[ DiskName[0]
WinHex软件 FAT32文件系统解析与提出
weixin_51624616的博客
05-27 2307
通常DBR位于文件系统的“”，用于记录分区中文件系统数据区对应簇的使用状态及文件不连续状态下的前后链接关系。FAT32文件系统中，统一在数据区的根目录区为根目录创建目录项，并由FAT表为文件的内容分配簇来存放数据。用“（文件夹位置-根目录位置）*每簇扇区数”得出文件夹的实际位置。读取第四列“A”“B”处数据 ，读取到的数据为“1971”，读取第二行“C”"D""E""F"处数据，读取到的数据为“读取第二行“C”"D""E""F"处数据，读取到的数据为“数据区的起始位置为根目录的起始位置，根目录位置固定为。
fat32源码c语言,FAT32文件系统基本原理与数据恢复编程
weixin_39927848的博客
05-21 1344
之前一直想把自己开发的数据恢复软件开源，但一直没有进行基本原理、研发过程文档的编写和代码的整理，这几天找出以前的源码，再补充几篇基本原理和研发思路的博文。为什么会有数据恢复软件？平时我们使用电脑的时候，会发现删除文件的速度比拷贝文件的速度快很多，但这是为什么呢？这里就有文件系统的基本原理了，我们在创建文件的时候，文件系统会创建文件文件名、属性信息、文件内容，但我们在删除文件的时候，文件系统只会将我...
Qt C++ 动态检测优盘插入或拔出
03-28
在开发文件浏览相关应用时，会涉及到动态检测优盘插入或拔出的状态，这样可以实时的刷新界面显示。这里通过调用windows的接口来实现该检测，代码很简单。我是在Qt工程中使用的，其核心代码是一样的。
c语言fat32文件格式,FAT32文件系统格式浅析
weixin_39706861的博客
05-23 513
A FAT file system volume is composed of four basic regionswhich are laid out in this order on the volume:0 – Reserved Region1 – FAT Region2 – Root Directory Region (doesn’t exist on FAT32 volumes)3 – ...
Qt C++ 检测优盘插入或拔出
hw5230的博客
03-10 888
在开发文件浏览相关应用时，会涉及到动态检测优盘插入或拔出的状态，这样可以实时的刷新界面显示。这里通过调用windows的接口来实现该检测，代码很简单。我是在Qt工程中使用的，其核心代码是一样的。
USB应用开发笔记之一：STM32上实现USB主机读写U盘
热门推荐
木南创智
08-21 2万+
  在项目应用中，经常会有对外交换数据的需求。USB接口读写U盘无疑是一种颇为方便的选择。在这一篇中，我们就来讨论如何在STM32上实现USB主机读写U盘文件的方法。 1、应用概述   在我们的产品上有这样一个需求，希望通过大容量的U盘存取数据。我们来分析一下这个需求的具体内容。   首先在硬件上我们需要有相应的USB端口，这一点在产品设计时就已经考虑并实现，所以硬件方面我们就不再过多的表述。   其次我们需要为这个USB的硬件接口编写驱动，就是实现USB端口的底层操作，如IO配置、终端处理等，这是移植的主
C++ 实现usb插入操作监控
Felix_Dreammaker的博客
01-24 6428
// usbTest.cpp: 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include #include #include using namespace std; #include /*-------------------------------------------------------------
FAT32文件系统 C语言源代码.doc
07-02
总结来说，这段C语言源代码是用于操作FAT32文件系统的，包括读写扇区、管理簇、处理分区和引导扇区信息，以及与硬件接口的交互。它适用于嵌入式系统，特别是那些需要直接与存储设备打交道的设备。
51单片机上移植的FAT文件系统，可以成功读取FAT32文件系统的SD卡里面的文件.zip
06-13
在提供的"51单片机上移植的FAT文件系统，可以成功读取FAT32文件系统的SD卡里面的文件.zip"中，主要包含了一个名为"FAT32.rar"的压缩文件。这个RAR文件可能包含了移植过程中所需的所有资源，如源代码、库文件、文档...
读取U盘物理序列号（转载的先放到这里研究下）
weixin_34411563的博客
02-18 1432
// usb.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" /************************************************************* Win32控制台应用程序 编译环境：Visual Studio 2005 主要功能： 1). 读取U盘序列号，保存在USBSeria...
教程一:windows api(c mfc vs2017)实现U盘插拔检测，获取U盘容量，U盘内容移动，开启和关闭U盘以及获取盘符等
qq_39861376的博客
10-22 1610
c++是大二下学期的专业课，大家可能都学过，这里主要介绍U盘这个小项目要用到没学过的知识。(踩坑合集) U盘完整项目源代码下载地址：https://download.csdn.net/download/qq_39861376/11888792 实验报告下载：https://download.csdn.net/download/qq_39861376/11937766 如果想要本节的源代码，请...
磁盘（含优盘识别）读写速度测试
笔直的一道弯
08-08 5688
可以测试驱动器（包含优盘自动识别插入、卸载）的读（Read）写（Write）速度，并以图形化的方式直观显示读写按照二进制形式进行测试程序运行效果图如下：  主要源码如下：1、柱状图控件源码Public Class SpeedViewClass SpeedView    Private xStep, yStep As Single    Private mMaxSpe
U盘直接读写(今天用到了)
weixin_30338743的博客
10-27 246
#ifndef INVALID_SET_FILE_POINTER #define INVALID_SET_FILE_POINTER (DWORD)-1 #endif #define FILE_BEGIN 0 #define FILE_CURRENT 1 #define FILE_END 2 HANDLE m_hDi...
C++如何检测磁盘是否为USB
字节跳动
03-12 894
C++如何检测磁盘是否为USB 一、解决方案 1 检测磁盘属性 2 判断STORAGE_BUS_TYPE是否为BusTypeUsb，确定USB类型 二、技术 1 获取磁盘设备句柄，如C盘。 注意：C盘设备名为L"\\.\C:"，不要写错。 2 检测磁盘属性 注意：操作控制码为IOCTL_STORAGE_QUERY_PROPERTY 三、实现 #include <Windows.h>...
请使用C语言实现FAT32文件系统
04-18
非常抱歉，由于我是一个自然语言处理的AI模型，无法提供具体的编程实现。但是，我可以提供一些相关的资源来帮助你进行FAT32文件系统的实现，例如FAT32文件系统的规格说明书，以及一些代码库和工具，如fat32lib、FatFs等，它们可以帮助你进行FAT32文件系统的实现。希望这些资源能对您有所帮助。
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值