dir.c

来自「ReactOS是一些高手根据Windows XP的内核编写出的类XP。内核实现机」· C语言 代码 · 共 660 行 · 第 1/2 页

    	buffer [strlen (buffer) - 1] = 0;
    for (;;) {
    	strcat (buffer, PATH_SEP_STR "..");
        p = vfs_canon (buffer);
        if (mc_stat (p, &((list->list) [index].buf)) != -1){
	    free (p);
            break;
	}
        i = 1;
        if ((s = vfs_path (p)) && !strcmp (s, PATH_SEP_STR)){
	    free (p);
            return 1;
	}
	strcpy (buffer, p);
	free (p);
    }

/* Commented out to preserve a usable '..'. What's the purpose of this
 * three lines? (Norbert) */
#if 0
    if (i) { /* So there is bogus information on the .. directory's stat */
        (list->list) [index].buf.st_mode &= ~0444;
    }
#endif
    return 1;
}

/* Used to set up a directory list when there is no access to a directory */
int set_zero_dir (dir_list *list)
{
    return (add_dotdot_to_list (list, 0));
}

/* If you change handle_dirent then check also handle_path. */
/* Return values: -1 = failure, 0 = don't add, 1 = add to the list */
int handle_dirent (dir_list *list, char *filter, struct dirent *dp,
		   struct stat *buf1, int next_free, int *link_to_dir,
		   int *stalled_link)
{
    if (dp->d_name [0] == '.' && dp->d_name [1] == 0)
	return 0;
    if (!show_dot_files){
	if (dp->d_name [0] == '.'){
	    if (!(dp->d_name [1] == 0))
		if (!(dp->d_name [1] == '.' && NLENGTH (dp) == 2))
		    return 0;
	}
    }
    if (!show_backups && dp->d_name [NLENGTH (dp)-1] == '~')
	return 0;
    if (mc_lstat (dp->d_name, buf1) == -1)
        return 0;

    if (S_ISDIR (buf1->st_mode))
	tree_check (dp->d_name);

    /* A link to a file or a directory? */
    *link_to_dir = 0;
    *stalled_link = 0;
    if (S_ISLNK(buf1->st_mode)){
	struct stat buf2;
	if (!mc_stat (dp->d_name, &buf2))
	    *link_to_dir = S_ISDIR(buf2.st_mode) != 0;
	else
	    *stalled_link = 1;
    }
    if (!(S_ISDIR(buf1->st_mode) || *link_to_dir) && filter &&
	!regexp_match (filter, dp->d_name, match_file))
	return 0;

    /* Need to grow the *list? */
    if (next_free == list->size){
	list->list = realloc (list->list, sizeof (file_entry) *
			      (list->size + RESIZE_STEPS));
	if (!list->list)
	    return -1;
	list->size += RESIZE_STEPS;
    }
    return 1;
}

/* handle_path is a simplified handle_dirent. The difference is that
   handle_path doesn't pay attention to show_dot_files and show_backups.
   Moreover handle_path can't be used with a filemask.
   If you change handle_path then check also handle_dirent. */
/* Return values: -1 = failure, 0 = don't add, 1 = add to the list */
int handle_path (dir_list *list, char *path,
		   struct stat *buf1, int next_free, int *link_to_dir,
		   int *stalled_link)
{
    if (path [0] == '.' && path [1] == 0)
	return 0;
    if (mc_lstat (path, buf1) == -1)
        return 0;

    if (S_ISDIR (buf1->st_mode))
	tree_check (path);

    /* A link to a file or a directory? */
    *link_to_dir = 0;
    *stalled_link = 0;
    if (S_ISLNK(buf1->st_mode)){
	struct stat buf2;
	if (!mc_stat (path, &buf2))
	    *link_to_dir = S_ISDIR(buf2.st_mode) != 0;
	else
	    *stalled_link = 1;
    }

    /* Need to grow the *list? */
    if (next_free == list->size){
	list->list = realloc (list->list, sizeof (file_entry) *
			      (list->size + RESIZE_STEPS));
	if (!list->list)
	    return -1;
	list->size += RESIZE_STEPS;
    }
    return 1;
}

int do_load_dir(dir_list *list, sortfn *sort, int reverse, int case_sensitive, char *filter)
{
    DIR           *dirp;
    struct dirent *dp;
    int           status, link_to_dir, stalled_link;
    int           next_free = 0;
    struct stat   buf;
    int dotdot_found = 0;

    start_tree_check (NULL);

    dirp = mc_opendir (".");
    if (!dirp){
	return set_zero_dir (list);
    }
    for (dp = mc_readdir (dirp); dp; dp = mc_readdir (dirp)){
	status = handle_dirent (list, filter, dp, &buf, next_free, &link_to_dir,
	    &stalled_link);
	if (status == 0)
	    continue;
	if (status == -1)
	    return next_free;
	list->list [next_free].fnamelen = NLENGTH (dp);
	list->list [next_free].fname = strdup (dp->d_name);
	list->list [next_free].cache = NULL;
	list->list [next_free].f.marked = 0;
	list->list [next_free].f.link_to_dir = link_to_dir;
	list->list [next_free].f.stalled_link = stalled_link;
	list->list [next_free].buf = buf;
	if (strcmp (dp->d_name, ".." ) == 0)
	    dotdot_found = 1;
	next_free++;
	if (!(next_free % 32))
	    rotate_dash ();
    }

    if (next_free) {
	if (!dotdot_found)
	    add_dotdot_to_list (list, next_free++);
	do_sort (list, sort, next_free-1, reverse, case_sensitive);
    }
    else
	return set_zero_dir (list);

    mc_closedir (dirp);
    end_tree_check (NULL);
    return next_free;
}

int link_isdir (file_entry *file)
{
    struct stat b;

    if (S_ISLNK (file->buf.st_mode)){
	mc_stat (file->fname, &b);
	if (S_ISDIR (b.st_mode))
	    return 1;
    }
    return 0;
}

int if_link_is_exe (file_entry *file)
{
    struct stat b;

    if (S_ISLNK (file->buf.st_mode)){
	mc_stat (file->fname, &b);
	return is_exe (b.st_mode);
    }
    return 1;
}

static dir_list dir_copy = { 0, 0 };

static void alloc_dir_copy (int size)
{
    int i;

    if (dir_copy.size < size){
	if (dir_copy.list){

	    for (i = 0; i < dir_copy.size; i++) {
		if (dir_copy.list [i].fname)
		    free (dir_copy.list [i].fname);
		if (dir_copy.list [i].cache)
		    free (dir_copy.list [i].cache);
	    }
	    free (dir_copy.list);
	    dir_copy.list = 0;
	}

	dir_copy.list = xmalloc (sizeof (file_entry) * size, "alloc_dir_copy");
	for (i = 0; i < size; i++) {
	    dir_copy.list [i].fname = 0;
	    dir_copy.list [i].cache = NULL;
	}
	dir_copy.size = size;
    }
}

/* If filter is null, then it is a match */
int do_reload_dir (dir_list *list, sortfn *sort, int count, int rev,
		   int case_sensitive, char *filter)
{
    DIR           *dirp;
    struct dirent *dp;
    int           next_free = 0;
    int           i, found, status, link_to_dir, stalled_link;
    struct stat   buf;
    int		  tmp_len;  /* For optimisation */
    int 	  dotdot_found = 0;

    start_tree_check (NULL);
    dirp = mc_opendir (".");
    if (!dirp) {
 	clean_dir (list, count);
	return set_zero_dir (list);
    }

    alloc_dir_copy (list->size);
    for (i = 0; i < count; i++){
	dir_copy.list [i].fnamelen = list->list [i].fnamelen;
	dir_copy.list [i].fname =    list->list [i].fname;
	dir_copy.list [i].cache =    list->list [i].cache;
	dir_copy.list [i].f.marked = list->list [i].f.marked;
	dir_copy.list [i].f.link_to_dir = list->list [i].f.link_to_dir;
	dir_copy.list [i].f.stalled_link = list->list [i].f.stalled_link;
    }

    for (dp = mc_readdir (dirp); dp; dp = mc_readdir (dirp)){
	status = handle_dirent (list, filter, dp, &buf, next_free, &link_to_dir,
	    &stalled_link);
	if (status == 0)
	    continue;
	if (status == -1) {
	    mc_closedir (dirp);
	    /* Norbert (Feb 12, 1997):
	     Just in case someone finds this memory leak:
	     -1 means big trouble (at the moment no memory left),
	     I don't bother with further cleanup because if one gets to
	     this point he will have more problems than a few memory
	     leaks and because one 'clean_dir' would not be enough (and
	     because I don't want to spent the time to make it working,
             IMHO it's not worthwhile).
	    clean_dir (&dir_copy, count);
             */
	    return next_free;
	}

	tmp_len = NLENGTH (dp);
	for (found = i = 0; i < count; i++)
	    if (tmp_len == dir_copy.list [i].fnamelen
		&& !strcmp (dp->d_name, dir_copy.list [i].fname)){
		list->list [next_free].f.marked = dir_copy.list [i].f.marked;
		found = 1;
		break;
	    }

	if (!found)
	    list->list [next_free].f.marked = 0;

	list->list [next_free].fnamelen = tmp_len;
	list->list [next_free].fname = strdup (dp->d_name);
	list->list [next_free].cache = NULL;
	list->list [next_free].f.link_to_dir = link_to_dir;
	list->list [next_free].f.stalled_link = stalled_link;
	list->list [next_free].buf = buf;
	if (strcmp (dp->d_name, ".." ) == 0)
	    dotdot_found = 1;
	next_free++;
	if (!(next_free % 16))
	    rotate_dash ();
    }
    mc_closedir (dirp);
    end_tree_check (NULL);
    if (next_free) {
	if (!dotdot_found)
	    add_dotdot_to_list (list, next_free++);
	do_sort (list, sort, next_free-1, rev, case_sensitive);
    }
    else
	next_free = set_zero_dir (list);
    clean_dir (&dir_copy, count);
    return next_free;
}

char *sort_type_to_name (sortfn *sort_fn)
{
    int i;

    for (i = 0; i < SORT_TYPES; i++)
	if ((sortfn *) (sort_orders [i].sort_fn) == sort_fn)
	    return _(sort_orders [i].sort_name);

    return _("Unknown");
}

sortfn *sort_name_to_type (char *sname)
{
    int i;

    for (i = 0; i < SORT_TYPES; i++)
	if (strcasecmp (sort_orders [i].sort_name, sname) == 0)
	    return (sortfn *) sort_orders [i].sort_fn;

    /* default case */
    return (sortfn *) sort_name;
}