transcode/patches/transcode-1.0.3-bigdir.patch

Submitted By: Chipster <chipster19@free.fr>
Date: 2007-06-02
Initial Package Version: 1.0.3
Upstream Status: Unknown
Origin: http://mirror.linux.org.mt/mirror/gentoo-portage/media-video/transcode/files
Description: 

--- transcode-1.0.3/import/iodump.c.old	2005-07-04 09:09:34.000000000 +0200
+++ transcode-1.0.3/import/iodump.c	2005-11-20 23:35:22.000000000 +0100
@@ -52,139 +52,217 @@
 
 static int verbose_flag=TC_QUIET;
 
-static DIR *dir=NULL;
+typedef struct tcdirlist_ TCDirList;
+struct tcdirlist_ {
+    DIR *dir;	/* for internal use */
+
+    const char *dir_name; /* saved base path */
+    const char *path_sep; /* optional *nix path separator */
+
+    char filename[PATH_MAX + 2]; 
+    /* 
+     * full path of file actually under focus + optional separator +
+     * final string terminator
+     */
+    char **entries;
+    /* array of full PATHs of files in scanned dirlist */
+
+    int nfiles; /* (current) number of files in dirlist */
+    int findex; /* index of file under focus */
+    int buffered;
+    /* boolean flag: above array of file in directory is valid? */
+};
 
-static char filename[PATH_MAX+2];
 
-static char **rbuf_ptr;
-
-static int nfiles=0, findex=0, buffered=0;  
-
-int open_directory(char	*dir_name)
+static int compare_name(const void *file1_ptr, const void *file2_ptr)
 {
-  if((dir = opendir(dir_name))==NULL) return(-1);
-  return(0);
+    return strcoll(*(const char **)file1_ptr, *(const char **)file2_ptr);
 }
 
-static char *scan_directory(char *dir_name)
-{ 
-  struct dirent *dent;
-  char *end_of_dir;
-  int len;
-  
-  if (dir_name == 0) return NULL;
-  if (dir == 0) return NULL;
-  
-  len = strlen( dir_name );
-  end_of_dir = &dir_name[ len - 1 ];
-  
-  if ( *end_of_dir != '/' ) { 
-      end_of_dir++;
-      *end_of_dir = '/';
-      end_of_dir++;
-      *end_of_dir = 0;	
-  }
-  
-  switch(buffered) {
-      
-  case 0:
-      
-      while((dent = readdir( dir ))!=NULL) {
-	  
-	  if((strncmp(dent->d_name, ".", 1)==0) || (strcmp(dent->d_name, "..")==0)) 
-	      continue;
-	  
-	  snprintf(filename, sizeof(filename), "%s%s", dir_name, dent->d_name);
+static int tc_dirlist_next(TCDirList *tcdir)
+{
+    struct dirent *dent = NULL;
+    int have_file = 0;
 
-	  //counter 
-	  ++nfiles;
-	  
-	  return(filename);
-      }
-      
-      break;
-      
-  case 1:
-      
-      if (findex < nfiles) {
-	  return(rbuf_ptr[findex++]); 
-      } else {
-	  return(NULL);
-      }
+    if (tcdir == NULL) {
+        return -1;
+    }
 
-      break;
-  }
-  
-  return(NULL);
+    do {
+        dent = readdir(tcdir->dir);
+        if (dent == NULL) {
+            break; /* all entries in dirlist have been processed */
+        }
+
+        if ((strncmp(dent->d_name, ".", 1) != 0)
+          && (strcmp(dent->d_name, "..") != 0)) {
+            /* discard special files */
+            have_file = 1;
+        }
+
+    } while (!have_file);
+
+    if (have_file) {
+        int res = snprintf(tcdir->filename, sizeof(tcdir->filename),
+                          "%s%s%s", tcdir->dir_name, tcdir->path_sep,
+                          dent->d_name);
+        /* enforce string terminator */
+        tcdir->filename[sizeof(tcdir->filename)] = '\0';
+        tc_test_string(__FILE__, __LINE__, 
+                       sizeof(tcdir->filename), res, errno);
+        return 0;
+    }
+    return 1;
 }
 
-
-static int compare_name(char **file1_ptr, char **file2_ptr)
+static int tc_dirlist_sortbuf(TCDirList *tcdir)
 {
-    return strcoll(*file1_ptr, *file2_ptr);
-}
+    int n = 0;
 
+    if (tcdir == NULL) {
+        return -1;
+    }
 
-int sortbuf_directory(char *dir_name)
-{ 
-  struct dirent *dent;
-  char *end_of_dir;
-  int n, len;
+    tcdir->entries = malloc(tcdir->nfiles * sizeof(char *));
+    if (tcdir->entries == NULL) {
+        fprintf(stderr, "(%s) can't allocate memory for "
+                        "directory entries\n", __FILE__);
+        return -1;
+    }
 
-  int (*func) ();
-  
-  if (dir_name == 0) return(-1);
-  if (dir == 0) return(-1);
-  if(nfiles == 0) return(-1);
-  
-  len = strlen( dir_name );
-  end_of_dir = &dir_name[ len - 1 ];
-  
-  if ( *end_of_dir != '/' ) { 
-    end_of_dir++;
-    *end_of_dir = '/';
-    end_of_dir++;
-    *end_of_dir = 0;	
-  }
-  
-  if((rbuf_ptr = (char **) calloc(nfiles, sizeof(char *)))==NULL) {
-      perror("out of memory");
-      return(-1);
-  }
-  
-  n=0;
+    while (tc_dirlist_next(tcdir) == 0) {
+        tcdir->entries[n] = strdup(tcdir->filename);
+        if (tcdir->entries[n] == NULL) {
+            fprintf(stderr, "(%s) can't memorize dirlist entry "
+                                  "for '%s'\n", __FILE__, 
+                                  tcdir->filename);
+        }
+        n++;
+    }
 
-  while((dent = readdir( dir ))!=NULL) {
-    
-    if((strncmp(dent->d_name, ".", 1)==0) || (strcmp(dent->d_name, "..")==0)) 
-      continue;
-    
-    snprintf(filename, sizeof(filename), "%s%s", dir_name, dent->d_name);
-    rbuf_ptr[n++] = strdup(filename);
-  }
-  
-  // sorting
+    qsort(tcdir->entries, tcdir->nfiles, sizeof(char *), compare_name);
 
-  func = compare_name;
+    tcdir->buffered = 1;
+    tcdir->findex = 0;
 
-  qsort(rbuf_ptr, nfiles, sizeof(char *), func);
+    return 0;
+}
+
+static int tc_dirlist_set_path_sep(TCDirList *tcdir)
+{
+    size_t len = 0;
+    char end_of_dir;
 
-  buffered=1;
-  findex=0;
+    len = strlen(tcdir->dir_name);
+    if (len == 0) {
+        return -1;
+    }
 
-  return(0);
+    end_of_dir = tcdir->dir_name[len - 1];
+    if (end_of_dir == '/') {
+        tcdir->path_sep = "";
+    } else {
+        tcdir->path_sep = "/";
+    }
+
+    return 0;
+}
+
+static int tc_dirlist_file_count(TCDirList *tcdir)
+{
+    if (tcdir == NULL) {
+        return -1;
+    }
+    return tcdir->nfiles;
 }
 
 
-void close_directory()
+static int tc_dirlist_open(TCDirList *tcdir, const char *dirname)
+{
+    int ret;
+    
+    if (tcdir == NULL) {
+        return -1;
+    }
+
+    tcdir->filename[0] = '\0';
+    tcdir->entries = NULL;
+    tcdir->nfiles = 0;
+    tcdir->findex = 0;
+    tcdir->buffered = 0;
+    tcdir->dir_name = dirname;
+    
+    ret = tc_dirlist_set_path_sep(tcdir);
+    if (ret != 0) {
+        return ret;
+    }
+    
+    tcdir->dir = opendir(dirname);
+    if (tcdir->dir == NULL) {
+        return -1;
+    }
+
+    rewinddir(tcdir->dir);
+    while (tc_dirlist_next(tcdir) == 0) {
+        tcdir->nfiles++;
+    }
+    rewinddir(tcdir->dir);
+    
+    return 0;
+}
+
+static void tc_dirlist_close(TCDirList *tcdir)
 {
-    if(dir!=NULL) closedir(dir);
-    dir=NULL;
+    if (tcdir != NULL) {
+        if (tcdir->buffered == 1) {
+            int i = 0;
+            for (i = 0; i < tcdir->nfiles; i++) {
+                if (tcdir->entries[i] != NULL) {
+                    /* should be always true */
+                    free(tcdir->entries[i]);
+                    tcdir->nfiles--;
+                }
+            }
+
+            if (tcdir->entries != NULL) {
+                /* should be always true */
+                free(tcdir->entries);
+            }
+
+            if (tcdir->nfiles > 0) {
+                /* should never happen */
+                fprintf(stderr, "(%s) left out %i directory entries",
+                            __FILE__, tcdir->nfiles);
+            }
+        }
+
+        if (tcdir->dir != NULL) {
+            closedir(tcdir->dir);
+            tcdir->dir = NULL;
+        }
+    }
 }
 
-void freebuf_directory()
+static char *tc_dirlist_scan(TCDirList *tcdir)
 {
-    free(rbuf_ptr);
+    char *ret = NULL;
+
+    if (tcdir == NULL) {
+        return NULL;
+    }
+     
+    if (tcdir->buffered == 0) {
+        if (tc_dirlist_next(tcdir) == 0) {
+            ret = tcdir->filename;
+        }
+    } else { /* tcdir->buffered == 0 */
+        /* buffered */
+        if (tcdir->findex < tcdir->nfiles) {
+            ret = tcdir->entries[tcdir->findex++];
+        }
+    }
+
+    return ret;
 }
 
 /* ------------------------------------------------------------ 
@@ -203,6 +281,7 @@
 
   info_t ipipe_avi;
 
+  TCDirList tcdir;
 #ifdef NET_STREAM
   struct sockaddr_in sin;
   struct hostent *hp;
@@ -326,13 +405,13 @@
     
     //PASS 1: check file type - file order not important
 
-    if((open_directory(ipipe->name))<0) { 
+    if(tc_dirlist_open(&tcdir, ipipe->name)<0) { 
       fprintf(stderr, "(%s) unable to open directory \"%s\"\n", __FILE__, ipipe->name);
       exit(1);
     } else if(verbose_flag & TC_DEBUG) 
       fprintf(stderr, "(%s) scanning directory \"%s\"\n", __FILE__, ipipe->name);
     
-    while((name=scan_directory(ipipe->name))!=NULL) {	
+    while((name=tc_dirlist_scan(&tcdir))!=NULL) {	
       
       if((ipipe->fd_in = open(name, O_RDONLY))<0) {
 	perror("file open");
@@ -386,7 +465,7 @@
       } // check itype
     } // process files
     
-    close_directory();
+    tc_dirlist_close(&tcdir);
     
     if(!found) {
       fprintf(stderr,"\nerror: no valid files found in %s\n", name);
@@ -398,17 +477,17 @@
     
     //PASS 2: dump files in correct order
     
-    if((open_directory(ipipe->name))<0) { 
+    if(tc_dirlist_open(&tcdir, ipipe->name)<0) { 
       fprintf(stderr, "(%s) unable to sort directory entries\"%s\"\n", __FILE__, name);
       exit(1);
     }
 
-    if((sortbuf_directory(ipipe->name))<0) { 
+    if(tc_dirlist_sortbuf(&tcdir)<0) { 
       fprintf(stderr, "(%s) unable to sort directory entries\"%s\"\n", __FILE__, name);
       exit(1);
     }
     
-    while((name=scan_directory(ipipe->name))!=NULL) {
+    while((name=tc_dirlist_scan(&tcdir))!=NULL) {
       
       if((ipipe->fd_in = open(name, O_RDONLY))<0) {
 	perror("file open");
@@ -480,9 +559,8 @@
       close(ipipe->fd_in);
 
     }//process files
-    
-    close_directory();
-    freebuf_directory();
+   
+    tc_dirlist_close(&tcdir);
 
     break;
   }
@@ -492,24 +570,25 @@
 int fileinfo_dir(char *dname, int *fd, long *magic)
 {    
     char *name=NULL;
+    TCDirList tcdir;
     
     //check file type - file order not important
     
-    if((open_directory(dname))<0) { 
+    if(tc_dirlist_open(&tcdir, dname)<0) { 
 	fprintf(stderr, "(%s) unable to open directory \"%s\"\n", __FILE__, dname);
 	exit(1);
     } else if(verbose_flag & TC_DEBUG) 
 	
 	fprintf(stderr, "(%s) scanning directory \"%s\"\n", __FILE__, dname);
     
-    if((name=scan_directory(dname))==NULL) return(-1); 	
+    if((name=tc_dirlist_scan(&tcdir))==NULL) return(-1); 	
 
     if((*fd= open(name, O_RDONLY))<0) {
 	perror("open file");
 	return(-1);
     }
 
-    close_directory();
+    tc_dirlist_close(&tcdir);
     
     //first valid magic must be the same for all
     //files to follow, but is not checked here
1	niro	618	Submitted By: Chipster <chipster19@free.fr>
2			Date: 2007-06-02
3			Initial Package Version: 1.0.3
4			Upstream Status: Unknown
5			Origin: http://mirror.linux.org.mt/mirror/gentoo-portage/media-video/transcode/files
6			Description:
7
8			--- transcode-1.0.3/import/iodump.c.old 2005-07-04 09:09:34.000000000 +0200
9			+++ transcode-1.0.3/import/iodump.c 2005-11-20 23:35:22.000000000 +0100
10			@@ -52,139 +52,217 @@
11
12			static int verbose_flag=TC_QUIET;
13
14			-static DIR *dir=NULL;
15			+typedef struct tcdirlist_ TCDirList;
16			+struct tcdirlist_ {
17			+ DIR dir; / for internal use */
18			+
19			+ const char dir_name; / saved base path */
20			+ const char path_sep; / optional nix path separator /
21			+
22			+ char filename[PATH_MAX + 2];
23			+ /*
24			+ * full path of file actually under focus + optional separator +
25			+ * final string terminator
26			+ */
27			+ char **entries;
28			+ /* array of full PATHs of files in scanned dirlist */
29			+
30			+ int nfiles; /* (current) number of files in dirlist */
31			+ int findex; /* index of file under focus */
32			+ int buffered;
33			+ /* boolean flag: above array of file in directory is valid? */
34			+};
35
36			-static char filename[PATH_MAX+2];
37
38			-static char **rbuf_ptr;
39			-
40			-static int nfiles=0, findex=0, buffered=0;
41			-
42			-int open_directory(char *dir_name)
43			+static int compare_name(const void file1_ptr, const void file2_ptr)
44			{
45			- if((dir = opendir(dir_name))==NULL) return(-1);
46			- return(0);
47			+ return strcoll((const char )file1_ptr, (const char **)file2_ptr);
48			}
49
50			-static char scan_directory(char dir_name)
51			-{
52			- struct dirent *dent;
53			- char *end_of_dir;
54			- int len;
55			-
56			- if (dir_name == 0) return NULL;
57			- if (dir == 0) return NULL;
58			-
59			- len = strlen( dir_name );
60			- end_of_dir = &dir_name[ len - 1 ];
61			-
62			- if ( *end_of_dir != '/' ) {
63			- end_of_dir++;
64			- *end_of_dir = '/';
65			- end_of_dir++;
66			- *end_of_dir = 0;
67			- }
68			-
69			- switch(buffered) {
70			-
71			- case 0:
72			-
73			- while((dent = readdir( dir ))!=NULL) {
74			-
75			- if((strncmp(dent->d_name, ".", 1)==0) \|\| (strcmp(dent->d_name, "..")==0))
76			- continue;
77			-
78			- snprintf(filename, sizeof(filename), "%s%s", dir_name, dent->d_name);
79			+static int tc_dirlist_next(TCDirList *tcdir)
80			+{
81			+ struct dirent *dent = NULL;
82			+ int have_file = 0;
83
84			- //counter
85			- ++nfiles;
86			-
87			- return(filename);
88			- }
89			-
90			- break;
91			-
92			- case 1:
93			-
94			- if (findex < nfiles) {
95			- return(rbuf_ptr[findex++]);
96			- } else {
97			- return(NULL);
98			- }
99			+ if (tcdir == NULL) {
100			+ return -1;
101			+ }
102
103			- break;
104			- }
105			-
106			- return(NULL);
107			+ do {
108			+ dent = readdir(tcdir->dir);
109			+ if (dent == NULL) {
110			+ break; /* all entries in dirlist have been processed */
111			+ }
112			+
113			+ if ((strncmp(dent->d_name, ".", 1) != 0)
114			+ && (strcmp(dent->d_name, "..") != 0)) {
115			+ /* discard special files */
116			+ have_file = 1;
117			+ }
118			+
119			+ } while (!have_file);
120			+
121			+ if (have_file) {
122			+ int res = snprintf(tcdir->filename, sizeof(tcdir->filename),
123			+ "%s%s%s", tcdir->dir_name, tcdir->path_sep,
124			+ dent->d_name);
125			+ /* enforce string terminator */
126			+ tcdir->filename[sizeof(tcdir->filename)] = '\0';
127			+ tc_test_string(__FILE__, __LINE__,
128			+ sizeof(tcdir->filename), res, errno);
129			+ return 0;
130			+ }
131			+ return 1;
132			}
133
134			-
135			-static int compare_name(char file1_ptr, char file2_ptr)
136			+static int tc_dirlist_sortbuf(TCDirList *tcdir)
137			{
138			- return strcoll(file1_ptr, file2_ptr);
139			-}
140			+ int n = 0;
141
142			+ if (tcdir == NULL) {
143			+ return -1;
144			+ }
145
146			-int sortbuf_directory(char *dir_name)
147			-{
148			- struct dirent *dent;
149			- char *end_of_dir;
150			- int n, len;
151			+ tcdir->entries = malloc(tcdir->nfiles * sizeof(char *));
152			+ if (tcdir->entries == NULL) {
153			+ fprintf(stderr, "(%s) can't allocate memory for "
154			+ "directory entries\n", __FILE__);
155			+ return -1;
156			+ }
157
158			- int (*func) ();
159			-
160			- if (dir_name == 0) return(-1);
161			- if (dir == 0) return(-1);
162			- if(nfiles == 0) return(-1);
163			-
164			- len = strlen( dir_name );
165			- end_of_dir = &dir_name[ len - 1 ];
166			-
167			- if ( *end_of_dir != '/' ) {
168			- end_of_dir++;
169			- *end_of_dir = '/';
170			- end_of_dir++;
171			- *end_of_dir = 0;
172			- }
173			-
174			- if((rbuf_ptr = (char *) calloc(nfiles, sizeof(char )))==NULL) {
175			- perror("out of memory");
176			- return(-1);
177			- }
178			-
179			- n=0;
180			+ while (tc_dirlist_next(tcdir) == 0) {
181			+ tcdir->entries[n] = strdup(tcdir->filename);
182			+ if (tcdir->entries[n] == NULL) {
183			+ fprintf(stderr, "(%s) can't memorize dirlist entry "
184			+ "for '%s'\n", __FILE__,
185			+ tcdir->filename);
186			+ }
187			+ n++;
188			+ }
189
190			- while((dent = readdir( dir ))!=NULL) {
191			-
192			- if((strncmp(dent->d_name, ".", 1)==0) \|\| (strcmp(dent->d_name, "..")==0))
193			- continue;
194			-
195			- snprintf(filename, sizeof(filename), "%s%s", dir_name, dent->d_name);
196			- rbuf_ptr[n++] = strdup(filename);
197			- }
198			-
199			- // sorting
200			+ qsort(tcdir->entries, tcdir->nfiles, sizeof(char *), compare_name);
201
202			- func = compare_name;
203			+ tcdir->buffered = 1;
204			+ tcdir->findex = 0;
205
206			- qsort(rbuf_ptr, nfiles, sizeof(char *), func);
207			+ return 0;
208			+}
209			+
210			+static int tc_dirlist_set_path_sep(TCDirList *tcdir)
211			+{
212			+ size_t len = 0;
213			+ char end_of_dir;
214
215			- buffered=1;
216			- findex=0;
217			+ len = strlen(tcdir->dir_name);
218			+ if (len == 0) {
219			+ return -1;
220			+ }
221
222			- return(0);
223			+ end_of_dir = tcdir->dir_name[len - 1];
224			+ if (end_of_dir == '/') {
225			+ tcdir->path_sep = "";
226			+ } else {
227			+ tcdir->path_sep = "/";
228			+ }
229			+
230			+ return 0;
231			+}
232			+
233			+static int tc_dirlist_file_count(TCDirList *tcdir)
234			+{
235			+ if (tcdir == NULL) {
236			+ return -1;
237			+ }
238			+ return tcdir->nfiles;
239			}
240
241
242			-void close_directory()
243			+static int tc_dirlist_open(TCDirList tcdir, const char dirname)
244			+{
245			+ int ret;
246			+
247			+ if (tcdir == NULL) {
248			+ return -1;
249			+ }
250			+
251			+ tcdir->filename[0] = '\0';
252			+ tcdir->entries = NULL;
253			+ tcdir->nfiles = 0;
254			+ tcdir->findex = 0;
255			+ tcdir->buffered = 0;
256			+ tcdir->dir_name = dirname;
257			+
258			+ ret = tc_dirlist_set_path_sep(tcdir);
259			+ if (ret != 0) {
260			+ return ret;
261			+ }
262			+
263			+ tcdir->dir = opendir(dirname);
264			+ if (tcdir->dir == NULL) {
265			+ return -1;
266			+ }
267			+
268			+ rewinddir(tcdir->dir);
269			+ while (tc_dirlist_next(tcdir) == 0) {
270			+ tcdir->nfiles++;
271			+ }
272			+ rewinddir(tcdir->dir);
273			+
274			+ return 0;
275			+}
276			+
277			+static void tc_dirlist_close(TCDirList *tcdir)
278			{
279			- if(dir!=NULL) closedir(dir);
280			- dir=NULL;
281			+ if (tcdir != NULL) {
282			+ if (tcdir->buffered == 1) {
283			+ int i = 0;
284			+ for (i = 0; i < tcdir->nfiles; i++) {
285			+ if (tcdir->entries[i] != NULL) {
286			+ /* should be always true */
287			+ free(tcdir->entries[i]);
288			+ tcdir->nfiles--;
289			+ }
290			+ }
291			+
292			+ if (tcdir->entries != NULL) {
293			+ /* should be always true */
294			+ free(tcdir->entries);
295			+ }
296			+
297			+ if (tcdir->nfiles > 0) {
298			+ /* should never happen */
299			+ fprintf(stderr, "(%s) left out %i directory entries",
300			+ __FILE__, tcdir->nfiles);
301			+ }
302			+ }
303			+
304			+ if (tcdir->dir != NULL) {
305			+ closedir(tcdir->dir);
306			+ tcdir->dir = NULL;
307			+ }
308			+ }
309			}
310
311			-void freebuf_directory()
312			+static char tc_dirlist_scan(TCDirList tcdir)
313			{
314			- free(rbuf_ptr);
315			+ char *ret = NULL;
316			+
317			+ if (tcdir == NULL) {
318			+ return NULL;
319			+ }
320			+
321			+ if (tcdir->buffered == 0) {
322			+ if (tc_dirlist_next(tcdir) == 0) {
323			+ ret = tcdir->filename;
324			+ }
325			+ } else { /* tcdir->buffered == 0 */
326			+ /* buffered */
327			+ if (tcdir->findex < tcdir->nfiles) {
328			+ ret = tcdir->entries[tcdir->findex++];
329			+ }
330			+ }
331			+
332			+ return ret;
333			}
334
335			/* ------------------------------------------------------------
336			@@ -203,6 +281,7 @@
337
338			info_t ipipe_avi;
339
340			+ TCDirList tcdir;
341			#ifdef NET_STREAM
342			struct sockaddr_in sin;
343			struct hostent *hp;
344			@@ -326,13 +405,13 @@
345
346			//PASS 1: check file type - file order not important
347
348			- if((open_directory(ipipe->name))<0) {
349			+ if(tc_dirlist_open(&tcdir, ipipe->name)<0) {
350			fprintf(stderr, "(%s) unable to open directory \"%s\"\n", __FILE__, ipipe->name);
351			exit(1);
352			} else if(verbose_flag & TC_DEBUG)
353			fprintf(stderr, "(%s) scanning directory \"%s\"\n", __FILE__, ipipe->name);
354
355			- while((name=scan_directory(ipipe->name))!=NULL) {
356			+ while((name=tc_dirlist_scan(&tcdir))!=NULL) {
357
358			if((ipipe->fd_in = open(name, O_RDONLY))<0) {
359			perror("file open");
360			@@ -386,7 +465,7 @@
361			} // check itype
362			} // process files
363
364			- close_directory();
365			+ tc_dirlist_close(&tcdir);
366
367			if(!found) {
368			fprintf(stderr,"\nerror: no valid files found in %s\n", name);
369			@@ -398,17 +477,17 @@
370
371			//PASS 2: dump files in correct order
372
373			- if((open_directory(ipipe->name))<0) {
374			+ if(tc_dirlist_open(&tcdir, ipipe->name)<0) {
375			fprintf(stderr, "(%s) unable to sort directory entries\"%s\"\n", __FILE__, name);
376			exit(1);
377			}
378
379			- if((sortbuf_directory(ipipe->name))<0) {
380			+ if(tc_dirlist_sortbuf(&tcdir)<0) {
381			fprintf(stderr, "(%s) unable to sort directory entries\"%s\"\n", __FILE__, name);
382			exit(1);
383			}
384
385			- while((name=scan_directory(ipipe->name))!=NULL) {
386			+ while((name=tc_dirlist_scan(&tcdir))!=NULL) {
387
388			if((ipipe->fd_in = open(name, O_RDONLY))<0) {
389			perror("file open");
390			@@ -480,9 +559,8 @@
391			close(ipipe->fd_in);
392
393			}//process files
394			-
395			- close_directory();
396			- freebuf_directory();
397			+
398			+ tc_dirlist_close(&tcdir);
399
400			break;
401			}
402			@@ -492,24 +570,25 @@
403			int fileinfo_dir(char dname, int fd, long *magic)
404			{
405			char *name=NULL;
406			+ TCDirList tcdir;
407
408			//check file type - file order not important
409
410			- if((open_directory(dname))<0) {
411			+ if(tc_dirlist_open(&tcdir, dname)<0) {
412			fprintf(stderr, "(%s) unable to open directory \"%s\"\n", __FILE__, dname);
413			exit(1);
414			} else if(verbose_flag & TC_DEBUG)
415
416			fprintf(stderr, "(%s) scanning directory \"%s\"\n", __FILE__, dname);
417
418			- if((name=scan_directory(dname))==NULL) return(-1);
419			+ if((name=tc_dirlist_scan(&tcdir))==NULL) return(-1);
420
421			if((*fd= open(name, O_RDONLY))<0) {
422			perror("open file");
423			return(-1);
424			}
425
426			- close_directory();
427			+ tc_dirlist_close(&tcdir);
428
429			//first valid magic must be the same for all
430			//files to follow, but is not checked here