dir.c

一个linux下NTFS文件格式源代码

	error=ntfs_read_attr(walk->dir,walk->dir->vol->at_index_allocation,I30,
			     block*walk->dir->vol->clustersize,&io);
	if(error || io.size!=length){
		ntfs_error("read failed\n");
		ntfs_free(record);
		return 0;
	}
	if(!ntfs_check_index_record(walk->dir,record)){
		ntfs_error("%x is not an index record\n",block);
		ntfs_free(record);
		return 0;
	}
	offset=record+NTFS_GETU16(record+0x18)+0x18;
	oldblock=walk->block;
	walk->block=block;
	retval=ntfs_getdir_iterate(walk,record,offset);
	walk->block=oldblock;
	ntfs_free(record);
	return retval;
}

/* go down to the next block of entries. These collate before
   the current entry */
static int ntfs_descend(ntfs_iterate_s *walk, ntfs_u8 *start, ntfs_u8 *entry)
{
	int length=NTFS_GETU16(entry+8);
	int nextblock=NTFS_GETU32(entry+length-8);
	int error;

	if(!ntfs_entry_has_subnodes(entry)) {
		ntfs_error("illegal ntfs_descend call\n");
		return 0;
	}
	error=ntfs_getdir_record(walk,nextblock);
	if(!error && walk->type==DIR_INSERT && 
	   (walk->u.flags & ITERATE_SPLIT_DONE)){
		/* Split has occurred. Adjust entry, insert new_entry. */
		NTFS_PUTU32(entry+length-8,walk->newblock);
		/* Reset flags, as the current block might be split again. */
		walk->u.flags &= ~ITERATE_SPLIT_DONE;
		error=ntfs_dir_insert(walk,start,entry);
	}
	return error;
}

static int 
ntfs_getdir_iterate_byposition(ntfs_iterate_s *walk,char* start,char *entry)
{
	int retval=0;
	int curpos=0,destpos=0;
	int length;
	if(walk->u.pos!=0){
		if(ntfs_is_top(walk->u.pos))return 0;
		destpos=ntfs_pop(&walk->u.pos);
	}
	while(1){
		if(walk->u.pos==0)
		{
			if(ntfs_entry_has_subnodes(entry))
				ntfs_descend(walk,start,entry);
			else
				walk->u.pos=ntfs_top();
			if(ntfs_is_top(walk->u.pos) && !ntfs_entry_is_used(entry))
			{
				return 1;
			}
			walk->u.pos=ntfs_push(walk->u.pos,curpos);
			return 1;
		}
		if(curpos==destpos)
		{
			if(!ntfs_is_top(walk->u.pos) && ntfs_entry_has_subnodes(entry))
			{
				retval=ntfs_descend(walk,start,entry);
				if(retval){
					walk->u.pos=ntfs_push(walk->u.pos,curpos);
					return retval;
				}else{
					if(!ntfs_entry_is_used(entry))
						return 0;
					walk->u.pos=0;
				}
			}
			if(ntfs_entry_is_used(entry))
			{
				retval=ntfs_copyresult(walk->result,entry);
				walk->u.pos=0;
			}else{
				walk->u.pos=ntfs_top();
				return 0;
			}
		}
		curpos++;
		if(!ntfs_entry_is_used(entry))break;
		length=NTFS_GETU16(entry+8);
		if(!length){
			ntfs_error("infinite loop\n");
			break;
		}
		entry+=length;
	}
	return -1;
}
	
/* Iterate over a list of entries, either from an index block, or from
   the index root. 
   If searching BY_POSITION, pop the top index from the position. If the
   position stack is empty then, return the item at the index and set the
   position to the next entry. If the position stack is not empty, 
   recursively proceed for subnodes. If the entry at the position is the
   'end of dir' entry, return 'not found' and the empty stack.
   If searching BY_NAME, walk through the items until found or until
   one item is collated after the requested item. In the former case, return
   the result. In the latter case, recursively proceed to the subnodes.
   If 'end of dir' is reached, the name is not in the directory */
static int ntfs_getdir_iterate(ntfs_iterate_s *walk, char *start, char *entry)
{
	int length;
	int cmp;

	if(walk->type==BY_POSITION)
		return ntfs_getdir_iterate_byposition(walk,start,entry);
	do{
		/* if the current entry is a real one, compare with the
		   requested item. If the current entry is the last item,
		   it is always larger than the requested item */
		cmp = ntfs_entry_is_used(entry) ? ntfs_my_strcmp(walk,entry) : -1;
		switch(walk->type){
		case BY_NAME:
			switch(cmp)
			{
			case -1:return ntfs_entry_has_subnodes(entry)?
				       ntfs_descend(walk,start,entry):0;
			case  0:return ntfs_copyresult(walk->result,entry);
			case  1:break;
			}
			break;
		case DIR_INSERT:
			switch(cmp){
			case -1:return ntfs_entry_has_subnodes(entry)?
				       ntfs_descend(walk,start,entry):
					       ntfs_dir_insert(walk,start,entry);
			case  0:return EEXIST;
			case  1:break;
			}
			break;
		default:
			ntfs_error("TODO\n");
		}
		if(!ntfs_entry_is_used(entry))break;
		length=NTFS_GETU16(entry+8);
		if(!length){
			ntfs_error("infinite loop\n");
			break;
		}
		entry+=length;
	}while(1);
	return 0;
}

/*	Tree walking is done using position numbers. The following numbers have
    a special meaning:
        0    start (.)
        -1   no more entries
        -2   ..
    All other numbers encode sequences of indices. The sequence a,b,c is 
    encoded as <stop><c><b><a>, where <foo> is the encoding of foo. The
    first few integers are encoded as follows:
        0:    0000    1:    0010    2:    0100    3:    0110
        4:    1000    5:    1010    6:    1100 stop:    1110
        7:  000001    8:  000101	9:  001001   10:  001101
    The least significant bits give the width of this encoding, the
    other bits encode the value, starting from the first value of the 
    interval.
     tag     width  first value  last value
     0       3      0            6
     01      4      7            22
     011     5      23           54
     0111    6      55           119
     More values are hopefully not needed, as the file position has currently
     64 bits in total.
*/

/* Find an entry in the directory. Return 0 if not found, otherwise copy
   the entry to the result buffer. */
int ntfs_getdir(ntfs_iterate_s* walk)
{
	int length=walk->dir->vol->mft_recordsize;
	int retval,error;
	/* start at the index root.*/
	char *root=ntfs_malloc(length);
	ntfs_io io;

	if( !root )
		return ENOMEM;

	io.fn_put=ntfs_put;
	io.param=root;
	io.size=length;
	error=ntfs_read_attr(walk->dir,walk->dir->vol->at_index_root,
			     I30,0,&io);
	if(error)
	{
		ntfs_error("Not a directory\n");
		return 0;
	}
	walk->block=-1;
	/* FIXME: move these to walk */
	walk->dir->u.index.recordsize = NTFS_GETU32(root+0x8);
	walk->dir->u.index.clusters_per_record = NTFS_GETU32(root+0xC);
	/* FIXME: consistency check */
	/* skip header */
	retval = ntfs_getdir_iterate(walk,root,root+0x20);
	ntfs_free(root);
	return retval;
}

/* Find an entry in the directory by its position stack. Iteration starts
   if the stack is 0, in which case the position is set to the first item
   in the directory. If the position is nonzero, return the item at the
   position and change the position to the next item. The position is -1
   if there are no more items */
int ntfs_getdir_byposition(ntfs_iterate_s *walk)
{
	walk->type=BY_POSITION;
	return ntfs_getdir(walk);
}

/* Find an entry in the directory by its name. Return 0 if not found */
int ntfs_getdir_byname(ntfs_iterate_s *walk)
{
	walk->type=BY_NAME;
	return ntfs_getdir(walk);
}

int ntfs_getdir_unsorted(ntfs_inode *ino,ntfs_u32 *p_high,ntfs_u32* p_low,
			 int(*cb)(ntfs_u8*,void*),void *param)
{
	char *buf=0,*entry=0;
	ntfs_io io;
	int length;
	int block;
	int start;
	ntfs_attribute *attr;
	ntfs_volume *vol=ino->vol;
	int byte,bit;
	int error=0;

	if(!ino){
		ntfs_error("No inode passed to getdir_unsorted\n");
		return EINVAL;
	}
	if(!vol){
		ntfs_error("Inode %d has no volume\n",ino->i_number);
		return EINVAL;
	}
	ntfs_debug(DEBUG_DIR3,"unsorted 1\n");
	/* are we still in the index root */
	if(*p_high==0){
		buf=ntfs_malloc(length=vol->mft_recordsize);
		if( !buf )
			return ENOMEM;
		io.fn_put=ntfs_put;
		io.param=buf;
		io.size=length;
		error=ntfs_read_attr(ino,vol->at_index_root,I30,0,&io);
		if(error){
			ntfs_free(buf);
			return error;
		}
		ino->u.index.recordsize = NTFS_GETU32(buf+0x8);
		ino->u.index.clusters_per_record = NTFS_GETU32(buf+0xC);
		entry=buf+0x20;
		ntfs_debug(DEBUG_DIR3,"unsorted 2\n");
	}else{ /* we are in an index record */
		length=ino->u.index.recordsize;
		buf=ntfs_malloc(length);
		if( !buf )
			return ENOMEM;
		io.fn_put=ntfs_put;
		io.param=buf;
		io.size=length;
		/* 0 is index root, index allocation starts with 4 */
		block = *p_high - ino->u.index.clusters_per_record;
		error=ntfs_read_attr(ino,vol->at_index_allocation,I30,
				     block*vol->clustersize,&io);
		if(!error && io.size!=length)error=EIO;
		if(error){
			ntfs_error("read failed\n");
			ntfs_free(buf);
			return error;
		}
		if(!ntfs_check_index_record(ino,buf)){
			ntfs_error("%x is not an index record\n",block);
			ntfs_free(buf);
			return ENOTDIR;
		}
		entry=buf+NTFS_GETU16(buf+0x18)+0x18;
		ntfs_debug(DEBUG_DIR3,"unsorted 3\n");
	}

	/* process the entries */
	start=*p_low;
	while(ntfs_entry_is_used(entry)){
		ntfs_debug(DEBUG_DIR3,"unsorted 4\n");
		if(start)
			start--; /* skip entries that were already processed */
		else{
			ntfs_debug(DEBUG_DIR3,"unsorted 5\n");
			if((error=cb(entry,param)))
				/* the entry could not be processed */
				break;
			(*p_low)++;
		}
		entry+=NTFS_GETU16(entry+8);
	}

	ntfs_debug(DEBUG_DIR3,"unsorted 6\n");
	/* caller did not process all entries */
	if(error){
		ntfs_free(buf);
		ntfs_debug(DEBUG_DIR3,"unsorted 7\n");
		return error;
	}

	/* we have to locate the next record */
	ntfs_free(buf);
	buf=0;
	*p_low=0;
	attr=ntfs_find_attr(ino,vol->at_bitmap,I30);
	if(!attr){
		/* directory does not have index allocation */
		*p_high=0xFFFFFFFF;
		*p_low=0;
		ntfs_debug(DEBUG_DIR3,"unsorted 8\n");
		return 0;
	}
	buf=ntfs_malloc(length=attr->size);
	if( !buf )
		return ENOMEM;

	io.param=buf;
	io.size=length;
	error=ntfs_read_attr(ino,vol->at_bitmap,I30,0,&io);
	if(!error && io.size!=length)error=EIO;
	if(error){
		ntfs_free(buf);
		ntfs_debug(DEBUG_DIR3,"unsorted 9\n");
		return EIO;
	}
	attr=ntfs_find_attr(ino,vol->at_index_allocation,I30);
	while(1){
		if(*p_high*vol->clustersize > attr->size){
			/* no more index records */
			*p_high=0xFFFFFFFF;
			ntfs_free(buf);
			ntfs_debug(DEBUG_DIR3,"unsorted 10\n");
			return 0;
		}
		*p_high+=ino->u.index.clusters_per_record;
		byte=*p_high/ino->u.index.clusters_per_record-1;
		bit  = 1 << (byte & 7);
		byte = byte >> 3;
		/* this record is allocated */
		if(buf[byte] & bit)
			break;
	}
	ntfs_debug(DEBUG_DIR3,"unsorted 11\n");
	ntfs_free(buf);
	return 0;
}

int ntfs_dir_add(ntfs_inode *dir, ntfs_inode *new, ntfs_attribute *name)
{
	ntfs_iterate_s walk;
	int nsize,esize;
	ntfs_u8* entry,*ndata;
	int error;

	walk.type=DIR_INSERT;
	walk.dir=dir;
	walk.u.flags=0;
	nsize = name->size;
	ndata = name->d.data;
	walk.name=(ntfs_u16*)(ndata+0x42);
	walk.namelen=NTFS_GETU8(ndata+0x40);
	walk.new_entry_size = esize = ((nsize+0x18)/8)*8;
	walk.new_entry=entry=ntfs_malloc(esize);
	if(!entry)return ENOMEM;
	ntfs_bzero(entry,esize);
	NTFS_PUTINUM(entry,new);
	NTFS_PUTU16(entry+0x8,esize); /* size of entry */
	NTFS_PUTU16(entry+0xA,nsize); /* size of original name attribute */
	NTFS_PUTU32(entry+0xC,0);     /* FIXME: D-F? */
	ntfs_memcpy(entry+0x10,ndata,nsize);
	error=ntfs_getdir(&walk);
	if(walk.new_entry)
		ntfs_free(walk.new_entry);
	return error;
}

#if 0
int ntfs_dir_add1(ntfs_inode *dir,const char* name,int namelen,ntfs_inode *ino)
{
	ntfs_iterate_s walk;
	int error;
	int nsize;
	char *entry;
	ntfs_attribute *name_attr;
	error=ntfs_decodeuni(dir->vol,name,namelen,&walk.name,&walk.namelen);
	if(error)
		return error;
	/* FIXME: set flags */
	walk.type=DIR_INSERT;
	walk.dir=dir;
	/*walk.new=ino;*/
	/* prepare new entry */
	/* round up to a multiple of 8 */
	walk.new_entry_size = nsize = ((0x52+2*walk.namelen+7)/8)*8;
	walk.new_entry=entry=ntfs_malloc(nsize);
	if(!entry)
		return ENOMEM;
	ntfs_bzero(entry,nsize);
	NTFS_PUTINUM(entry,ino);
	NTFS_PUTU16(entry+8,nsize);
	NTFS_PUTU16(entry+0xA,0x42+2*namelen); /*FIXME: size of name attr*/
	NTFS_PUTU32(entry+0xC,0); /*FIXME: D-F? */
	name_attr=ntfs_find_attr(ino,vol->at_file_name,0); /* FIXME:multiple names */
	if(!name_attr || !name_attr->resident)
		return EIDRM;
	/* directory, file stamps, sizes, filename */
	ntfs_memcpy(entry+0x10,name_attr->d.data,0x42+2*namelen);
	error=ntfs_getdir(&walk);
	ntfs_free(walk.name);
	return error;
}
#endif

/* Fills out and creates an INDEX_ROOT attribute. */

int
ntfs_add_index_root (ntfs_inode *ino, int type)
{
	ntfs_attribute *da;
	ntfs_u8 data[0x30]; /* 0x20 header, 0x10 last entry */
	char name[10];

	NTFS_PUTU32(data, type);
	/* ??? */
	NTFS_PUTU32(data+4, 1);
	NTFS_PUTU32(data+8, ino->vol->index_recordsize);
	NTFS_PUTU32(data+0xC, ino->vol->index_clusters_per_record);
	/* ??? */
	NTFS_PUTU32(data+0x10, 0x10);
	/* Size of entries, including header. */
	NTFS_PUTU32(data+0x14, 0x20);
	NTFS_PUTU32(data+0x18, 0x20);
	/* No index allocation, yet. */
	NTFS_PUTU32(data+0x1C, 0);
	/* add last entry. */
	/* indexed MFT record. */
	NTFS_PUTU64(data+0x20, 0);
	/* size of entry */
	NTFS_PUTU32(data+0x28, 0x10);
	/* flags: last entry, no child nodes. */
	NTFS_PUTU32(data+0x2C, 2);
	/* compute name */
	ntfs_indexname(name, type);
	return ntfs_create_attr(ino, ino->vol->at_index_root, name,
				data, sizeof(data), &da);
}

int
ntfs_mkdir(ntfs_inode* dir,const char* name,int namelen, ntfs_inode *result)
{
	int error;
	error = ntfs_alloc_inode(dir, result, name, namelen, NTFS_AFLAG_DIR);
	if(error)
		goto out;
	error = ntfs_add_index_root(result, 0x30);
	if (error)
		goto out;
	/* Set directory bit */
	result->attr[0x16] |= 2;
	error = ntfs_update_inode (dir);
	if (error)
		goto out;
	error = ntfs_update_inode (result);
	if (error)
		goto out;
 out:
	return error;
}

/*
 * Local variables:
 * c-file-style: "linux"
 * End:
 */