예제 #1
0
//
//Copy a folder.This function makes recursive calls
// and once a regular file is encountered it calls 
// the CopyExt2File() function.
//
void CopyFolder(DWORD inode,DWORD peslb)
{
	int tdir =0;
	DWORD  prev_rec_len =0 ;
	BYTE inodebuf[512];
	struct ext2_inode *intab;
	BYTE dirbuf[4096];
	int i,k;
	DWORD inodesam;
	grblock = (struct group *)groupdescr;
	inodesam=Inode_to_Lba(inode);
	if(ReadDiskSector(inodebuf,disk,peslb+inodesam,1)==FALSE)
		PrintError("Can not read disk sector");
	i=Get_Index(inode);
    intab=(struct ext2_inode *)&inodebuf[i*128];

    for(k=0;k<12;k++)
    {  
		if(intab->i_block[k]!=0)
		{  
			prev_rec_len=0;
			do{
				strcpy(dirnam,"");
				if(ReadDiskSector(dirbuf,disk,peslb+(size/512)*intab->i_block[k],size/512)==FALSE)
					MessageBox(NULL , "Cannot Read Disk Sector ", "Error" , MB_OK);
				direntry=(struct ext2_dir_entry_2 *)&dirbuf[prev_rec_len];
				if(direntry->file_type==1)
				{
					strncpy(dirnam,direntry->name,direntry->name_len);
					dirnam[direntry->name_len]='\0';
		  
					CopyExt2File(direntry->inode,peslb,dirnam);
				}
				if(direntry->file_type==2 && strcmp(direntry->name,".") && strcmp(direntry->name,".."))
				{
					strncpy(dirnam,direntry->name,direntry->name_len);
					dirnam[direntry->name_len]='\0';
					_mkdir(dirnam);
					_chdir(dirnam);
					tdir=direntry->rec_len;
					CopyFolder(direntry->inode,peslb);
					_chdir("..");
					direntry->rec_len=tdir;
				}
				if(direntry->rec_len+prev_rec_len>=size) break;
					prev_rec_len = direntry->rec_len+prev_rec_len;
			}while(direntry->rec_len>0);
		}
    }
    return;
}
예제 #2
0
파일: Partit.c 프로젝트: sibiantony/tuxidow
// Read the MBR.The first 446 bytes are skipped.
// The next 64 bytes contains the partition table.
// and the last 2 bytes is the magic word "AA55"
void ReadMBR()
{
	
	BYTE buf[512],i;
	bslist=(struct bootsector *)malloc(sizeof(struct bootsector));
	bslist->next=NULL;
	
	ReadDiskSector(buf,disk,0,1);
	for(i=0;i<4;i++)
		bslist->part[i] = *((struct PartitionEntry*)&buf[446 + i*16]);
    	
	bslist->signature=*((WORD *)&buf[510]);


}
예제 #3
0
//Checks the super block of both the Ext2 as well
//as Reiser filesystems.
char * printsuper(enum DISK_TYPE disk,DWORD peslb)
{
	int l=0;
	if(ReadDiskSector(buf,disk,peslb+EXT2_SUPER_OFFSET,2)==FALSE)
		PrintError("Can not read disk sector");
    sb = (struct super_block *)malloc(sizeof(struct super_block));
 	sb = (struct super_block *)buf;
	if(sb->magic==0xEF53) 
	{
		strcpy(pathname[0],sb->volume_name);
		l = (int)strlen(pathname[0]);
		if(pathname[0][l-1]!='/')
		{
			pathname[0][l]='/';
			pathname[0][l+1]='\0';
		}
		address_len = (int)strlen(pathname[0]);
		size = (WORD)pow(2,10+sb->log_block_size);
		return sb->volume_name;
	}
	else
	{
		char magic[13],buf[512];
		reiser_sb = (struct reiser_super_block *)malloc(sizeof(struct reiser_super_block));
		if(ReadDiskSector(buf,disk,peslb+REISERFS_SUPER_OFFSET,1)==FALSE)
			PrintError("Can not read disk sector");
		reiser_sb=(struct reiser_super_block *)buf;
		wsprintf(magic,"%s",reiser_sb->magic);
		magic[12]='\0';
		if(strcmp(magic,"ReIsErFs")==0 || strcmp(magic,"ReIsEr2Fs")==0)
		{
			return ("ReiserFS");
  		}
	}
	return("No support");
}
예제 #4
0
void CopyExt2Block(DWORD block_address , FILE *outfile , int *blocksize)
{
	
	char dataread[4096];

	if(ReadDiskSector(dataread ,disk ,block_address,size/512)==FALSE)
			PrintError("Can not read disk sector");
	progress_count += 1;
	if(progress_count==progress_mode) 	
	{
		SendMessage(hwndPB, PBM_STEPIT, 0, 0);
		progress_count =0;
	}

	if(*blocksize > size)
	{
		fwrite((char *)&dataread,size,1,outfile);
		*blocksize = *blocksize - size;
	}
	else
		fwrite((char *)&dataread,(*blocksize),1,outfile);
}
예제 #5
0
파일: Partit.c 프로젝트: sibiantony/tuxidow
//Read the bootsectors and check whether 
//the signature is valid.
void GetBootSector(DWORD lba)
{
	BYTE buf[512],i;
	temp->next=(struct bootsector *)malloc(sizeof(struct bootsector));
	temp=temp->next;
	temp->next=NULL;
	if(ReadDiskSector(buf,disk,lba,1)==TRUE)
	{
          for(i=0;i<4;i++)
			temp->part[i]=*((struct PartitionEntry*)&buf[446 + i*16]);
		  
          temp->signature=*((WORD *)&buf[510]);
		if(temp->signature==0xAA55)
			CheckIfExt2FS(&temp->part[0],lba);
		else
			PrintError("\nBad signature...");
	}
	else
		PrintError("\n ReadSector failed ");
	if(temp->part[1].tb)
		GetBootSector(temp->part[1].slba+extlba);

}
예제 #6
0
//
//Traverse a directory.The data blocks are 
//mapped to the directory entry strcuture and 
//assign the details of the files into the guifile structure.
//
void printinode(enum DISK_TYPE disk,DWORD peslb,DWORD inode)
{   
	int k=0,i,num=0,small_size=0;
	WORD sindblock ;
	DWORD prev_rec_len=0;
	int count =0,isam;
	BYTE inodebuf[512],indbuf[512];
	BYTE sindbuf[4096];
	BYTE dirbuf[4097];
	DWORD past=0,inodesam;
	DWORD n=0,m=0 ,j;

	if((size==1024)||(size ==2048))
		n=4;
	else if(size==4096)
		n=8;

	if(ReadDiskSector(groupdescr,disk,peslb+n,1)==FALSE) 
		PrintError("Can not read disk sector");
	grblock=(struct group *)malloc(sizeof(struct group));
	grblock=(struct group *)groupdescr;
	do
	{
		inodesam=Inode_to_Lba(inode);
		if(ReadDiskSector(inodebuf,disk,peslb+inodesam,1)==FALSE)
			PrintError("Can not read disk sector");
		sb = (struct super_block *)buf;
		i=Get_Index(inode);
		intab[i]=(struct ext2_inode *)&inodebuf[i*128];
		k=(intab[i]->i_mode&0xF000)>>12 ;
   
	 /********************READING DIRECTORY ENTRY **********************/
	 //printf("******DIRECT DATA BLOCKS\n");
		for(k=0;k<12;k++)
		{
	
			if(intab[i]->i_block[k]!=0)
			{
				prev_rec_len=0;
				if(ReadDiskSector(dirbuf,disk,peslb+(size/512)*intab[i]->i_block[k],size/512)==FALSE)
					{
						MessageBox(NULL , "Cannot Read Disk Sector ", "Error" , MB_OK);
						exit(0);
						return;
					}
		 //printf("\n*****directory Entry*****%d\n",k);
				do
				{
					direntry=(struct ext2_dir_entry_2*)&dirbuf[prev_rec_len];			 
					strcpy(dirbuf,"");
					if(strcmp(direntry->name,".")==0){ present_inode=direntry->inode;goto da;}
					if(strcmp(direntry->name,"..")==0){ past=direntry->inode;}
					for(j=0;j<direntry->name_len;j++)
					{
						guifile[count].filename[j] = direntry->name[j];
					}
					guifile[count].filename[direntry->name_len]='\0';
					guifile[count].inode = direntry->inode;
					inodesam=Inode_to_Lba(direntry->inode);
					if(ReadDiskSector(indbuf,disk,peslb+inodesam,1)==FALSE)
						PrintError("Can not read disk sector");
					isam = Get_Index(direntry->inode);
					intab1[isam]=(struct ext2_inode *)&indbuf[isam*128];
					guifile[count].isize=intab1[isam]->i_size;
					guifile[count].file_type=direntry->file_type;
					strncpy(guifile[count].acrights,PrintMode(intab1[isam]->i_mode),13);
					count++;
			da:
					if(direntry->rec_len+prev_rec_len>=size) goto a;
					prev_rec_len = direntry->rec_len+prev_rec_len;
					
				} while(direntry->rec_len>0);
			}a: ;
		}
	 //*********************READING DATA BLOCK ************************
	 //singly indirect block 
       
	 
		if(intab[i]->i_block[12]!=0)
		{ 
		//printf("******SINGLY INDIRECT DATA BLOCK\n");
			sindblock=size/4;
			if(ReadDiskSector(sindbuf,disk,peslb+(size/512)*intab[i]->i_block[12],size/512)==FALSE)
				PrintError("Can not read disk sector");
			sind=(struct sindirect*)sindbuf;
			for(j=0;j<sindblock;j++)
			{     
				prev_rec_len=0;
				if(sind->add[j]!=0)
				{
					if(ReadDiskSector(dirbuf,disk,peslb+(size/512)*sind->add[j],8)==FALSE)
						PrintError("Can not read disk sector");
				//printf("\n*****directory Entry*****\n");
					do
					{
						direntry=(struct ext2_dir_entry_2*)&dirbuf[prev_rec_len];
						strcpy(dirbuf,"");
						//for(k=0;k<direntry->name_len;k++)
							//printf("%c",direntry->name[k]);
						direntry->name[direntry->name_len]='\0';
						strcpy(guifile[count].filename,direntry->name);
						guifile[count].inode = direntry->inode;
						inodesam=Inode_to_Lba(direntry->inode);
						if(ReadDiskSector(indbuf,disk,peslb+inodesam,1)==FALSE)
							PrintError("Can not read disk sector");
						isam = Get_Index(direntry->inode);
						intab1[isam]=(struct ext2_inode *)&indbuf[isam*128];
						guifile[count].file_type=direntry->file_type;
						strncpy(guifile[count].acrights,PrintMode(intab1[isam]->i_mode),13);
						count++;	
						if(direntry->rec_len+prev_rec_len>=size) goto b;
						prev_rec_len = direntry->rec_len+prev_rec_len;

					} while(direntry->rec_len>0);
				}
			b:;	 
			}
	 
		}
	//end:
	 num_files = count;
	 	
	}while(ch=='y');
}
예제 #7
0
//
//Save a file from the partition to a file.
//Checks all the singly, doubly and triply indirect 
//blocks and if allocated , calls the CopyExt2Block() function.
//
void CopyExt2File(DWORD inode,DWORD peslb,char * filename)
{
	FILE * outfile;
	int small_size=0,i;
	char *inodebuf ;       // to store the inode info of a file or folder		
	BYTE sindbuf[4096],dindbuf[4096],tindbuf[4096];
	WORD j , k ,sindblock;
	DWORD m,inodesam , fil_si ;
	struct ext2_inode *intab;
	struct tindirect  *tind;

	progress_count = 0;
	inodebuf = (char*)malloc(512);
	grblock = (struct group *)groupdescr;
	inodesam = Inode_to_Lba(inode);

	if(ReadDiskSector(inodebuf,disk,peslb+inodesam,1)==FALSE)
		PrintError("Can not read disk sector");
	i = Get_Index(inode);
	intab = (struct ext2_inode *)&inodebuf[i*128];
 	progress_mode = ((intab->i_size/PROGRESS_RANGE)/size);
	fil_si = intab->i_size;
	if((outfile = fopen(filename,"wb"))==NULL)
	{
		return;
	}
		/********** Copying Direct Blocks *********/
	for(m=0;m<12;m++)
	{
		if(intab->i_block[m]!=0)
			CopyExt2Block(peslb+(size/512)*intab->i_block[m],outfile ,&fil_si);
    }

		/********* Copying Singly Indirect Block ********/
	if(intab->i_block[12]!=0)
    {
		sindblock=size/4;
		if(ReadDiskSector(sindbuf,disk,peslb+(size/512)*intab->i_block[12],size/512)==FALSE)
			PrintError("Can not read disk sector");
		sind=(struct sindirect*)sindbuf;	//number of single indirect blocks
		for(j=0;j<sindblock;j++)
		{
			if(sind->add[j]!=0)
				CopyExt2Block(peslb+(size/512)*sind->add[j],outfile ,&fil_si);
		}
    }
	   
		/********** Copying Doubly Indirect Block *********/
	if(intab->i_block[13]!=0)
    {
		if(ReadDiskSector(dindbuf,disk,peslb+(size/512)*intab->i_block[13],size/512)==FALSE)
			PrintError("Can not read disk sector");
		dind = (struct dindirect*)dindbuf;
		for(j=0;j<sindblock;j++)
		{
			if(dind->add[j]!=0)
			{
				if(ReadDiskSector(sindbuf,disk,peslb+(size/512)*dind->add[j],size/512)==FALSE)
					PrintError("Can not read disk sector");
				sind = (struct sindirect*)sindbuf;
				for(k=0;k<sindblock;k++)
					if(sind->add[k]!=0)	
						CopyExt2Block(peslb+(size/512)*sind->add[k],
													outfile,&fil_si);
			}
		}
    }

		/********** Copying Triply Indirect Block ********/
	if(intab->i_block[14]!=0)
    {
		if(ReadDiskSector(tindbuf,disk,peslb+(size/512)*intab->i_block[14],size/512)==FALSE)
			PrintError("Can not read disk sector");

		tind = (struct tindirect*)tindbuf;
		for(m=0;m<sindblock;m++)
		{
			if(tind->add[m]!=0)
			{
				if(ReadDiskSector(dindbuf,disk,peslb+(size/512)*tind->add[m],size/512)==FALSE)
					PrintError("Can not read disk sector");

				dind = (struct dindirect*)dindbuf;
				for(j=0;j<sindblock;j++)
				{
					if(dind->add[j]!=0)
					{
						if(ReadDiskSector(sindbuf,disk,peslb+(size/512)*dind->add[j],size/512)==FALSE)
							PrintError("Can not read disk sector");
						sind = (struct sindirect*)sindbuf;
						for(k=0;k<sindblock;k++)
							if(sind->add[k]!=0)
								CopyExt2Block(peslb+(size/512)*sind->add[k],
															outfile ,&fil_si);		
					}	
				}  
			}
		}   
	}
	fclose(outfile);
	free(inodebuf);
}