src/filemanager/dir.c

   1 /*
   2    Directory routines
   3
   4    Copyright (C) 1994, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   5    2006, 2007, 2011
   6    The Free Software Foundation, Inc.
   7
   8    This file is part of the Midnight Commander.
   9
  10    The Midnight Commander is free software: you can redistribute it
  11    and/or modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation, either version 3 of the License,
  13    or (at your option) any later version.
  14
  15    The Midnight Commander is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22  */
  23
  24 /** \file dir.c
  25  *  \brief Source: directory routines
  26  */
  27
  28 #include <config.h>
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <sys/stat.h>
  34
  35 #include "lib/global.h"
  36 #include "lib/tty/tty.h"
  37 #include "lib/search.h"
  38 #include "lib/vfs/vfs.h"
  39 #include "lib/fs.h"
  40 #include "lib/strutil.h"
  41 #include "lib/util.h"
  42 #include "lib/widget.h"         /* message() */
  43
  44 #include "src/setup.h"          /* panels_options */
  45
  46 #include "treestore.h"
  47 #include "dir.h"
  48 #include "layout.h"             /* rotate_dash() */
  49
  50 /*** global variables ****************************************************************************/
  51
  52 /*** file scope macro definitions ****************************************************************/
  53
  54 #define MY_ISDIR(x) (\
  55     (is_exe (x->st.st_mode) && !(S_ISDIR (x->st.st_mode) || x->f.link_to_dir) && exec_first) \
  56         ? 1 \
  57         : ( (S_ISDIR (x->st.st_mode) || x->f.link_to_dir) ? 2 : 0) )
  58
  59 /*** file scope type declarations ****************************************************************/
  60
  61 /*** file scope variables ************************************************************************/
  62
  63 /* Reverse flag */
  64 static int reverse = 1;
  65
  66 /* Are the files sorted case sensitively? */
  67 static int case_sensitive = OS_SORT_CASE_SENSITIVE_DEFAULT;
  68
  69 /* Are the exec_bit files top in list */
  70 static gboolean exec_first = TRUE;
  71
  72 static dir_list dir_copy = { 0, 0 };
  73
  74 /*** file scope functions ************************************************************************/
  75 /* --------------------------------------------------------------------------------------------- */
  76
  77 /*
  78    sort_orders_t sort_orders [SORT_TYPES_TOTAL] = {
  79    { N_("&Unsorted"),    unsorted },
  80    { N_("&Name"),        sort_name },
  81    { N_("&Extension"),   sort_ext },
  82    { N_("&Modify time"), sort_time },
  83    { N_("&Access time"), sort_atime },
  84    { N_("C&Hange time"), sort_ctime },
  85    { N_("&Size"),        sort_size },
  86    { N_("&Inode"),       sort_inode },
  87    };
  88  */
  89
  90 static inline int
  91 key_collate (const char *t1, const char *t2)
  92 {
  93     int dotdot = 0;
  94     int ret;
  95
  96     dotdot = (t1[0] == '.' ? 1 : 0) | ((t2[0] == '.' ? 1 : 0) << 1);
  97
  98     switch (dotdot)
  99     {
 100     case 0:
 101     case 3:
 102         ret = str_key_collate (t1, t2, case_sensitive) * reverse;
 103         break;
 104     case 1:
 105         ret = -1;               /* t1 < t2 */
 106         break;
 107     case 2:
 108         ret = 1;                /* t1 > t2 */
 109         break;
 110     default:
 111         ret = 0;                /* it must not happen */
 112     }
 113
 114     return ret;
 115 }
 116
 117 /* --------------------------------------------------------------------------------------------- */
 118 /** clear keys, should be call after sorting is finished */
 119
 120 static void
 121 clean_sort_keys (dir_list * list, int start, int count)
 122 {
 123     int i;
 124
 125     for (i = 0; i < count; i++)
 126     {
 127         str_release_key (list->list[i + start].sort_key, case_sensitive);
 128         list->list[i + start].sort_key = NULL;
 129         str_release_key (list->list[i + start].second_sort_key, case_sensitive);
 130         list->list[i + start].second_sort_key = NULL;
 131     }
 132 }
 133
 134 /* --------------------------------------------------------------------------------------------- */
 135 /**
 136  * If you change handle_dirent then check also handle_path.
 137  * @returns -1 = failure, 0 = don't add, 1 = add to the list
 138  */
 139
 140 static int
 141 handle_dirent (dir_list * list, const char *fltr, struct dirent *dp,
 142                struct stat *buf1, int next_free, int *link_to_dir, int *stale_link)
 143 {
 144     vfs_path_t *vpath;
 145
 146     if (dp->d_name[0] == '.' && dp->d_name[1] == 0)
 147         return 0;
 148     if (dp->d_name[0] == '.' && dp->d_name[1] == '.' && dp->d_name[2] == 0)
 149         return 0;
 150     if (!panels_options.show_dot_files && (dp->d_name[0] == '.'))
 151         return 0;
 152     if (!panels_options.show_backups && dp->d_name[NLENGTH (dp) - 1] == '~')
 153         return 0;
 154
 155     vpath = vfs_path_from_str (dp->d_name);
 156     if (mc_lstat (vpath, buf1) == -1)
 157     {
 158         /*
 159          * lstat() fails - such entries should be identified by
 160          * buf1->st_mode being 0.
 161          * It happens on QNX Neutrino for /fs/cd0 if no CD is inserted.
 162          */
 163         memset (buf1, 0, sizeof (*buf1));
 164     }
 165
 166     if (S_ISDIR (buf1->st_mode))
 167         tree_store_mark_checked (dp->d_name);
 168
 169     /* A link to a file or a directory? */
 170     *link_to_dir = 0;
 171     *stale_link = 0;
 172     if (S_ISLNK (buf1->st_mode))
 173     {
 174         struct stat buf2;
 175         if (mc_stat (vpath, &buf2) == 0)
 176             *link_to_dir = S_ISDIR (buf2.st_mode) != 0;
 177         else
 178             *stale_link = 1;
 179     }
 180     vfs_path_free (vpath);
 181     if (!(S_ISDIR (buf1->st_mode) || *link_to_dir) && (fltr != NULL)
 182         && !mc_search (fltr, dp->d_name, MC_SEARCH_T_GLOB))
 183         return 0;
 184
 185     /* Need to grow the *list? */
 186     if (next_free == list->size)
 187     {
 188         list->list = g_try_realloc (list->list, sizeof (file_entry) * (list->size + RESIZE_STEPS));
 189         if (list->list == NULL)
 190             return -1;
 191         list->size += RESIZE_STEPS;
 192     }
 193     return 1;
 194 }
 195
 196 /* --------------------------------------------------------------------------------------------- */
 197 /** get info about ".." */
 198
 199 static gboolean
 200 get_dotdot_dir_stat (const vfs_path_t * vpath, struct stat *st)
 201 {
 202     gboolean ret = FALSE;
 203
 204     if ((vpath != NULL) && (st != NULL))
 205     {
 206         const char *path;
 207
 208         path = vfs_path_get_by_index (vpath, 0)->path;
 209         if (path != NULL && *path != '\0')
 210         {
 211             vfs_path_t *tmp_vpath;
 212             struct stat s;
 213
 214             tmp_vpath = vfs_path_append_new (vpath, "..", NULL);
 215             ret = mc_stat (tmp_vpath, &s) == 0;
 216             vfs_path_free (tmp_vpath);
 217             *st = s;
 218         }
 219     }
 220
 221     return ret;
 222 }
 223
 224 /* --------------------------------------------------------------------------------------------- */
 225
 226 static void
 227 alloc_dir_copy (int size)
 228 {
 229     if (dir_copy.size < size)
 230     {
 231         if (dir_copy.list)
 232         {
 233             int i;
 234             for (i = 0; i < dir_copy.size; i++)
 235                 g_free (dir_copy.list[i].fname);
 236             g_free (dir_copy.list);
 237         }
 238
 239         dir_copy.list = g_new0 (file_entry, size);
 240         dir_copy.size = size;
 241     }
 242 }
 243
 244 /* --------------------------------------------------------------------------------------------- */
 245 /*** public functions ****************************************************************************/
 246 /* --------------------------------------------------------------------------------------------- */
 247
 248 int
 249 unsorted (file_entry * a, file_entry * b)
 250 {
 251     (void) a;
 252     (void) b;
 253     return 0;
 254 }
 255
 256 /* --------------------------------------------------------------------------------------------- */
 257
 258 int
 259 sort_name (file_entry * a, file_entry * b)
 260 {
 261     int ad = MY_ISDIR (a);
 262     int bd = MY_ISDIR (b);
 263
 264     if (ad == bd || panels_options.mix_all_files)
 265     {
 266         /* create key if does not exist, key will be freed after sorting */
 267         if (a->sort_key == NULL)
 268             a->sort_key = str_create_key_for_filename (a->fname, case_sensitive);
 269         if (b->sort_key == NULL)
 270             b->sort_key = str_create_key_for_filename (b->fname, case_sensitive);
 271
 272         return key_collate (a->sort_key, b->sort_key);
 273     }
 274     return bd - ad;
 275 }
 276
 277 /* --------------------------------------------------------------------------------------------- */
 278
 279 int
 280 sort_vers (file_entry * a, file_entry * b)
 281 {
 282     int ad = MY_ISDIR (a);
 283     int bd = MY_ISDIR (b);
 284
 285     if (ad == bd || panels_options.mix_all_files)
 286     {
 287         return str_verscmp (a->fname, b->fname) * reverse;
 288     }
 289     else
 290     {
 291         return bd - ad;
 292     }
 293 }
 294
 295 /* --------------------------------------------------------------------------------------------- */
 296
 297 int
 298 sort_ext (file_entry * a, file_entry * b)
 299 {
 300     int r;
 301     int ad = MY_ISDIR (a);
 302     int bd = MY_ISDIR (b);
 303
 304     if (ad == bd || panels_options.mix_all_files)
 305     {
 306         if (a->second_sort_key == NULL)
 307             a->second_sort_key = str_create_key (extension (a->fname), case_sensitive);
 308         if (b->second_sort_key == NULL)
 309             b->second_sort_key = str_create_key (extension (b->fname), case_sensitive);
 310
 311         r = str_key_collate (a->second_sort_key, b->second_sort_key, case_sensitive);
 312         if (r)
 313             return r * reverse;
 314         else
 315             return sort_name (a, b);
 316     }
 317     else
 318         return bd - ad;
 319 }
 320
 321 /* --------------------------------------------------------------------------------------------- */
 322
 323 int
 324 sort_time (file_entry * a, file_entry * b)
 325 {
 326     int ad = MY_ISDIR (a);
 327     int bd = MY_ISDIR (b);
 328
 329     if (ad == bd || panels_options.mix_all_files)
 330     {
 331         int result = a->st.st_mtime < b->st.st_mtime ? -1 : a->st.st_mtime > b->st.st_mtime;
 332         if (result != 0)
 333             return result * reverse;
 334         else
 335             return sort_name (a, b);
 336     }
 337     else
 338         return bd - ad;
 339 }
 340
 341 /* --------------------------------------------------------------------------------------------- */
 342
 343 int
 344 sort_ctime (file_entry * a, file_entry * b)
 345 {
 346     int ad = MY_ISDIR (a);
 347     int bd = MY_ISDIR (b);
 348
 349     if (ad == bd || panels_options.mix_all_files)
 350     {
 351         int result = a->st.st_ctime < b->st.st_ctime ? -1 : a->st.st_ctime > b->st.st_ctime;
 352         if (result != 0)
 353             return result * reverse;
 354         else
 355             return sort_name (a, b);
 356     }
 357     else
 358         return bd - ad;
 359 }
 360
 361 /* --------------------------------------------------------------------------------------------- */
 362
 363 int
 364 sort_atime (file_entry * a, file_entry * b)
 365 {
 366     int ad = MY_ISDIR (a);
 367     int bd = MY_ISDIR (b);
 368
 369     if (ad == bd || panels_options.mix_all_files)
 370     {
 371         int result = a->st.st_atime < b->st.st_atime ? -1 : a->st.st_atime > b->st.st_atime;
 372         if (result != 0)
 373             return result * reverse;
 374         else
 375             return sort_name (a, b);
 376     }
 377     else
 378         return bd - ad;
 379 }
 380
 381 /* --------------------------------------------------------------------------------------------- */
 382
 383 int
 384 sort_inode (file_entry * a, file_entry * b)
 385 {
 386     int ad = MY_ISDIR (a);
 387     int bd = MY_ISDIR (b);
 388
 389     if (ad == bd || panels_options.mix_all_files)
 390         return (a->st.st_ino - b->st.st_ino) * reverse;
 391     else
 392         return bd - ad;
 393 }
 394
 395 /* --------------------------------------------------------------------------------------------- */
 396
 397 int
 398 sort_size (file_entry * a, file_entry * b)
 399 {
 400     int ad = MY_ISDIR (a);
 401     int bd = MY_ISDIR (b);
 402     int result = 0;
 403
 404     if (ad != bd && !panels_options.mix_all_files)
 405         return bd - ad;
 406
 407     result = a->st.st_size < b->st.st_size ? -1 : a->st.st_size > b->st.st_size;
 408     if (result != 0)
 409         return result * reverse;
 410     else
 411         return sort_name (a, b);
 412 }
 413
 414 /* --------------------------------------------------------------------------------------------- */
 415
 416 void
 417 do_sort (dir_list * list, sortfn * sort, int top, gboolean reverse_f, gboolean case_sensitive_f,
 418          gboolean exec_first_f)
 419 {
 420     int dot_dot_found = 0;
 421
 422     if (top == 0)
 423         return;
 424
 425     /* If there is an ".." entry the caller must take care to
 426        ensure that it occupies the first list element. */
 427     if (strcmp (list->list[0].fname, "..") == 0)
 428         dot_dot_found = 1;
 429
 430     reverse = reverse_f ? -1 : 1;
 431     case_sensitive = case_sensitive_f ? 1 : 0;
 432     exec_first = exec_first_f;
 433     qsort (&(list->list)[dot_dot_found], top + 1 - dot_dot_found, sizeof (file_entry), sort);
 434
 435     clean_sort_keys (list, dot_dot_found, top + 1 - dot_dot_found);
 436 }
 437
 438 /* --------------------------------------------------------------------------------------------- */
 439
 440 void
 441 clean_dir (dir_list * list, int count)
 442 {
 443     int i;
 444
 445     for (i = 0; i < count; i++)
 446     {
 447         g_free (list->list[i].fname);
 448         list->list[i].fname = NULL;
 449     }
 450 }
 451
 452 /* --------------------------------------------------------------------------------------------- */
 453 /** Used to set up a directory list when there is no access to a directory */
 454
 455 gboolean
 456 set_zero_dir (dir_list * list)
 457 {
 458     /* Need to grow the *list? */
 459     if (list->size == 0)
 460     {
 461         list->list = g_try_realloc (list->list, sizeof (file_entry) * (list->size + RESIZE_STEPS));
 462         if (list->list == NULL)
 463             return FALSE;
 464
 465         list->size += RESIZE_STEPS;
 466     }
 467
 468     memset (&(list->list)[0], 0, sizeof (file_entry));
 469     list->list[0].fnamelen = 2;
 470     list->list[0].fname = g_strndup ("..", list->list[0].fnamelen);
 471     list->list[0].f.link_to_dir = 0;
 472     list->list[0].f.stale_link = 0;
 473     list->list[0].f.dir_size_computed = 0;
 474     list->list[0].f.marked = 0;
 475     list->list[0].st.st_mode = 040755;
 476     return TRUE;
 477 }
 478
 479 /* --------------------------------------------------------------------------------------------- */
 480 /**
 481    handle_path is a simplified handle_dirent. The difference is that
 482    handle_path doesn't pay attention to panels_options.show_dot_files
 483    and panels_options.show_backups.
 484    Moreover handle_path can't be used with a filemask.
 485    If you change handle_path then check also handle_dirent. */
 486 /* Return values: -1 = failure, 0 = don't add, 1 = add to the list */
 487
 488 int
 489 handle_path (dir_list * list, const char *path,
 490              struct stat *buf1, int next_free, int *link_to_dir, int *stale_link)
 491 {
 492     vfs_path_t *vpath;
 493
 494     if (path[0] == '.' && path[1] == 0)
 495         return 0;
 496     if (path[0] == '.' && path[1] == '.' && path[2] == 0)
 497         return 0;
 498
 499     vpath = vfs_path_from_str (path);
 500     if (mc_lstat (vpath, buf1) == -1)
 501     {
 502         vfs_path_free (vpath);
 503         return 0;
 504     }
 505
 506     if (S_ISDIR (buf1->st_mode))
 507         tree_store_mark_checked (path);
 508
 509     /* A link to a file or a directory? */
 510     *link_to_dir = 0;
 511     *stale_link = 0;
 512     if (S_ISLNK (buf1->st_mode))
 513     {
 514         struct stat buf2;
 515         if (mc_stat (vpath, &buf2) == 0)
 516             *link_to_dir = S_ISDIR (buf2.st_mode) != 0;
 517         else
 518             *stale_link = 1;
 519     }
 520
 521     vfs_path_free (vpath);
 522
 523     /* Need to grow the *list? */
 524     if (next_free == list->size)
 525     {
 526         list->list = g_try_realloc (list->list, sizeof (file_entry) * (list->size + RESIZE_STEPS));
 527             return -1;
 528         list->size += RESIZE_STEPS;
 529     }
 530     return 1;
 531 }
 532
 533 /* --------------------------------------------------------------------------------------------- */
 534
 535 int
 536 do_load_dir (const vfs_path_t * vpath, dir_list * list, sortfn * sort, gboolean lc_reverse,
 537              gboolean lc_case_sensitive, gboolean exec_ff, const char *fltr)
 538 {
 539     DIR *dirp;
 540     struct dirent *dp;
 541     int status, link_to_dir, stale_link;
 542     int next_free = 0;
 543     struct stat st;
 544
 545     /* ".." (if any) must be the first entry in the list */
 546     if (!set_zero_dir (list))
 547         return next_free;
 548
 549     if (get_dotdot_dir_stat (vpath, &st))
 550         list->list[next_free].st = st;
 551     next_free++;
 552
 553     dirp = mc_opendir (vpath);
 554     if (dirp == NULL)
 555     {
 556         message (D_ERROR, MSG_ERROR, _("Cannot read directory contents"));
 557         return next_free;
 558     }
 559
 560     tree_store_start_check (vpath);
 561
 562     /* Do not add a ".." entry to the root directory */
 563     if ((path[0] == PATH_SEP) && (path[1] == '\0'))
 564         next_free--;
 565
 566     while ((dp = mc_readdir (dirp)) != NULL)
 567     {
 568         status = handle_dirent (list, fltr, dp, &st, next_free, &link_to_dir, &stale_link);
 569         if (status == 0)
 570             continue;
 571         if (status == -1)
 572             goto ret;
 573
 574         list->list[next_free].fnamelen = NLENGTH (dp);
 575         list->list[next_free].fname = g_strndup (dp->d_name, list->list[next_free].fnamelen);
 576         list->list[next_free].f.marked = 0;
 577         list->list[next_free].f.link_to_dir = link_to_dir;
 578         list->list[next_free].f.stale_link = stale_link;
 579         list->list[next_free].f.dir_size_computed = 0;
 580         list->list[next_free].st = st;
 581         list->list[next_free].sort_key = NULL;
 582         list->list[next_free].second_sort_key = NULL;
 583         next_free++;
 584
 585         if ((next_free & 31) == 0)
 586             rotate_dash ();
 587     }
 588
 589     if (next_free != 0)
 590         do_sort (list, sort, next_free - 1, lc_reverse, lc_case_sensitive, exec_ff);
 591
 592   ret:
 593     mc_closedir (dirp);
 594     tree_store_end_check ();
 595     return next_free;
 596 }
 597
 598
 599 /* --------------------------------------------------------------------------------------------- */
 600
 601 gboolean
 602 if_link_is_exe (const vfs_path_t * full_name_vpath, const file_entry * file)
 603 {
 604     struct stat b;
 605
 606     if (S_ISLNK (file->st.st_mode) && mc_stat (full_name_vpath, &b) == 0)
 607         return is_exe (b.st_mode);
 608     return TRUE;
 609 }
 610
 611 /* --------------------------------------------------------------------------------------------- */
 612 /** If fltr is null, then it is a match */
 613
 614 int
 615 do_reload_dir (const vfs_path_t * vpath, dir_list * list, sortfn * sort, int count,
 616                gboolean lc_reverse, gboolean lc_case_sensitive, gboolean exec_ff, const char *fltr)
 617 {
 618     DIR *dirp;
 619     struct dirent *dp;
 620     int next_free = 0;
 621     int i, status, link_to_dir, stale_link;
 622     struct stat st;
 623     int marked_cnt;
 624     GHashTable *marked_files;
 625     const char *tmp_path;
 626
 627     dirp = mc_opendir (vpath);
 628     if (dirp == NULL)
 629     {
 630         message (D_ERROR, MSG_ERROR, _("Cannot read directory contents"));
 631         clean_dir (list, count);
 632         return set_zero_dir (list) ? 1 : 0;
 633     }
 634
 635     tree_store_start_check (vpath);
 636
 637     marked_files = g_hash_table_new (g_str_hash, g_str_equal);
 638     alloc_dir_copy (list->size);
 639     for (marked_cnt = i = 0; i < count; i++)
 640     {
 641         dir_copy.list[i].fnamelen = list->list[i].fnamelen;
 642         dir_copy.list[i].fname = list->list[i].fname;
 643         dir_copy.list[i].f.marked = list->list[i].f.marked;
 644         dir_copy.list[i].f.dir_size_computed = list->list[i].f.dir_size_computed;
 645         dir_copy.list[i].f.link_to_dir = list->list[i].f.link_to_dir;
 646         dir_copy.list[i].f.stale_link = list->list[i].f.stale_link;
 647         dir_copy.list[i].sort_key = NULL;
 648         dir_copy.list[i].second_sort_key = NULL;
 649         if (list->list[i].f.marked)
 650         {
 651             g_hash_table_insert (marked_files, dir_copy.list[i].fname, &dir_copy.list[i]);
 652             marked_cnt++;
 653         }
 654     }
 655
 656     /* Add ".." except to the root directory. The ".." entry
 657        (if any) must be the first in the list. */
 658     tmp_path = vfs_path_get_by_index (vpath, 0)->path;
 659     if (!
 660         (vfs_path_elements_count (vpath) == 1 && (tmp_path[0] == PATH_SEP)
 661          && (tmp_path[1] == '\0')))
 662     {
 663         if (!set_zero_dir (list))
 664         {
 665             clean_dir (list, count);
 666             clean_dir (&dir_copy, count);
 667             return next_free;
 668         }
 669
 670         if (get_dotdot_dir_stat (vpath, &st))
 671             list->list[next_free].st = st;
 672
 673         next_free++;
 674     }
 675
 676     while ((dp = mc_readdir (dirp)))
 677     {
 678         status = handle_dirent (list, fltr, dp, &st, next_free, &link_to_dir, &stale_link);
 679         if (status == 0)
 680             continue;
 681         if (status == -1)
 682         {
 683             mc_closedir (dirp);
 684             /* Norbert (Feb 12, 1997):
 685                Just in case someone finds this memory leak:
 686                -1 means big trouble (at the moment no memory left),
 687                I don't bother with further cleanup because if one gets to
 688                this point he will have more problems than a few memory
 689                leaks and because one 'clean_dir' would not be enough (and
 690                because I don't want to spent the time to make it working,
 691                IMHO it's not worthwhile).
 692                clean_dir (&dir_copy, count);
 693              */
 694             tree_store_end_check ();
 695             g_hash_table_destroy (marked_files);
 696             return next_free;
 697         }
 698
 699         list->list[next_free].f.marked = 0;
 700
 701         /*
 702          * If we have marked files in the copy, scan through the copy
 703          * to find matching file.  Decrease number of remaining marks if
 704          * we copied one.
 705          */
 706         if (marked_cnt > 0)
 707         {
 708             if ((g_hash_table_lookup (marked_files, dp->d_name)))
 709             {
 710                 list->list[next_free].f.marked = 1;
 711                 marked_cnt--;
 712             }
 713         }
 714
 715         list->list[next_free].fnamelen = NLENGTH (dp);
 716         list->list[next_free].fname = g_strndup (dp->d_name, list->list[next_free].fnamelen);
 717         list->list[next_free].f.link_to_dir = link_to_dir;
 718         list->list[next_free].f.stale_link = stale_link;
 719         list->list[next_free].f.dir_size_computed = 0;
 720         list->list[next_free].st = st;
 721         list->list[next_free].sort_key = NULL;
 722         list->list[next_free].second_sort_key = NULL;
 723         next_free++;
 724         if (!(next_free % 16))
 725             rotate_dash ();
 726     }
 727     mc_closedir (dirp);
 728     tree_store_end_check ();
 729     g_hash_table_destroy (marked_files);
 730     if (next_free)
 731     {
 732         do_sort (list, sort, next_free - 1, lc_reverse, lc_case_sensitive, exec_ff);
 733     }
 734     clean_dir (&dir_copy, count);
 735     return next_free;
 736 }
 737
 738 /* --------------------------------------------------------------------------------------------- */