glibc中scandir函数源码的疑问

changyongID

贴上代码之后，贴子显得比较长，但问题并不复杂。请各位看一下，问题描述如下


函数scandir一般是用来对指定目录排序中的。其在glibc中源码如下：

1. #include <dirent.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. #include <errno.h>
   
5. #include <bits/libc-lock.h>
   
6. 
   
7. #ifndef SCANDIR
   
8. #define SCANDIR scandir
   
9. #define READDIR __readdir
   
10. #define DIRENT_TYPE struct dirent
    
11. #endif
    
12. 
    
13. #ifndef SCANDIR_CANCEL
    
14. #define SCANDIR_CANCEL
    
15. struct scandir_cancel_struct
    
16. {
    
17.         DIR *dp;
    
18.         void *v;
    
19.         size_t cnt;
    
20. };
    
21. 
    
22. static void
    
23. cancel_handler (void *arg)
    
24. {
    
25.         struct scandir_cancel_struct *cp = arg;
    
26.         size_t i;
    
27.         void **v = cp->v;
    
28. 
    
29.         for (i = 0; i < cp->cnt; ++i)
    
30.                 free (v[i]);
    
31.         free (v);
    
32.         (void) __closedir (cp->dp);
    
33. }
    
34. #endif
    
35. 
    
36. 
    
37. int
    
38. SCANDIR (dir, namelist, select, cmp)
    
39.         const char *dir;
    
40.         DIRENT_TYPE ***namelist;
    
41.         int (*select) (const DIRENT_TYPE *);
    
42.         int (*cmp) (const void *, const void *);
    
43. {
    
44.         DIR *dp = __opendir (dir);
    
45.         DIRENT_TYPE **v = NULL;
    
46.         size_t vsize = 0;
    
47.         struct scandir_cancel_struct c;
    
48.         DIRENT_TYPE *d;
    
49.         int save;
    
50. 
    
51.         if (dp == NULL)
    
52.                 return -1;
    
53. 
    
54.         save = errno;
    
55.         __set_errno (0);
    
56. 
    
57.         c.dp = dp;
    
58.         c.v = NULL;
    
59.         c.cnt = 0;
    
60.         __libc_cleanup_push (cancel_handler, &c);
    
61. 
    
62.         while ((d = READDIR (dp)) != NULL)
    
63.         {
    
64.                 int use_it = select == NULL;
    
65. 
    
66.                 if (! use_it)
    
67.                 {
    
68.                         use_it = select (d);
    
69.                         /* The select function might have changed errno.  It was
    
70.                            zero before and it need to be again to make the latter
    
71.                            tests work.  */
    
72.                         __set_errno (0);
    
73.                 }
    
74. 
    
75.                 if (use_it)
    
76.                 {
    
77.                         DIRENT_TYPE *vnew;
    
78.                         size_t dsize;
    
79. 
    
80.                         /* Ignore errors from select or readdir */
    
81.                         __set_errno (0);
    
82. 
    
83.                         if (__builtin_expect (c.cnt == vsize, 0))
    
84.                         {
    
85.                                 DIRENT_TYPE **new;
    
86.                                 if (vsize == 0)
    
87.                                         vsize = 10;
    
88.                                 else
    
89.                                         vsize *= 2;
    
90.                                 new = (DIRENT_TYPE **) realloc (v, vsize * sizeof (*v));
    
91.                                 if (new == NULL)
    
92.                                         break;
    
93.                                 v = new;
    
94.                                 c.v = (void *) v;
    
95.                         }
    
96. 
    
97.                         dsize = &d->d_name[_D_ALLOC_NAMLEN (d)] - (char *) d;
    
98.                         vnew = (DIRENT_TYPE *) malloc (dsize);
    
99.                         if (vnew == NULL)
    
100.                                 break;
     
101. 
     
102.                         v[c.cnt++] = (DIRENT_TYPE *) memcpy (vnew, d, dsize);
     
103.                 }
     
104.         }
     
105. 
     
106.         if (__builtin_expect (errno, 0) != 0)
     
107.         {
     
108.                 save = errno;
     
109. 
     
110.                 while (c.cnt > 0)
     
111.                         free (v[--c.cnt]);
     
112.                 free (v);
     
113.                 c.cnt = -1;
     
114.         }
     
115.         else
     
116.         {
     
117.                 /* Sort the list if we have a comparison function to sort with.  */
     
118.                 if (cmp != NULL)
     
119.                         qsort (v, c.cnt, sizeof (*v), cmp);
     
120. 
     
121.                 *namelist = v;
     
122.         }
     
123. 
     
124.         __libc_cleanup_pop (0);
     
125. 
     
126.         (void) __closedir (dp);
     
127.         __set_errno (save);
     
128. 
     
129.         return c.cnt;
     
130. }
     

复制代码

其中可以看到，在函数退出时，调用了  __libc_cleanup_pop (0); 也就是要调用下面这个函数

static void
cancel_handler (void *arg)
{
        struct scandir_cancel_struct *cp = arg;
        size_t i;
        void **v = cp->v;

        for (i = 0; i < cp->cnt; ++i)
                free (v);
        free (v);
        (void) __closedir (cp->dp);
}
其中free(v)即将v所指向的内存释放掉了，这里的v是cp->v。而在主代码中可以看到 c.v = (void *) v;

看到这里，即scandir函数结束后，会将所有内存释放掉。连 new = (DIRENT_TYPE **) realloc (v, vsize * sizeof (*v)) 这一句所分配的内存也
释放了。
但主函数后面又有  *namelist = v; 使用scandir函数时通过这个namelist来访问排序过后的内存。
但上面的代码里明明就是把分配的内存释放掉了呀。

使用scandir的实例有

1. #include <dirent.h>
   
2. 
   
3.        int
   
4.        main(void)
   
5.        {
   
6.            struct dirent **namelist;
   
7.            int n;
   
8. 
   
9.            n = scandir(".", &namelist, 0, alphasort);
   
10.            if (n < 0)
    
11.                perror("scandir");
    
12.            else {
    
13.                while (n--) {
    
14.                    printf("%s\n", namelist[n]->d_name);
    
15.                    free(namelist[n]);
    
16.                }
    
17.                free(namelist);
    
18.            }
    
19.        }
    

复制代码

可以看到上面 free(namelist); 又将namelist指向的内存释放了一遍。。
这样一来不就free了两次了吗？

请指点！谢谢各位。

rain_fish

The scandir() function scans the directory dir, calling select() on each directory entry. Entries for which select() returns non-zero are stored in strings allocated via malloc(), sorted using qsort() with the comparison function compar(), and collected in array namelist which is allocated via malloc(). If select is NULL, all entries are selected.