1*a28cd43dSSascha Wildner /*
2*a28cd43dSSascha Wildner * Copyright (c) 2016-2020, Przemyslaw Skibinski, Yann Collet, Facebook, Inc.
3*a28cd43dSSascha Wildner * All rights reserved.
4*a28cd43dSSascha Wildner *
5*a28cd43dSSascha Wildner * This source code is licensed under both the BSD-style license (found in the
6*a28cd43dSSascha Wildner * LICENSE file in the root directory of this source tree) and the GPLv2 (found
7*a28cd43dSSascha Wildner * in the COPYING file in the root directory of this source tree).
8*a28cd43dSSascha Wildner * You may select, at your option, one of the above-listed licenses.
9*a28cd43dSSascha Wildner */
10*a28cd43dSSascha Wildner
11*a28cd43dSSascha Wildner #if defined (__cplusplus)
12*a28cd43dSSascha Wildner extern "C" {
13*a28cd43dSSascha Wildner #endif
14*a28cd43dSSascha Wildner
15*a28cd43dSSascha Wildner
16*a28cd43dSSascha Wildner /*-****************************************
17*a28cd43dSSascha Wildner * Dependencies
18*a28cd43dSSascha Wildner ******************************************/
19*a28cd43dSSascha Wildner #include "util.h" /* note : ensure that platform.h is included first ! */
20*a28cd43dSSascha Wildner #include <stdlib.h> /* malloc, realloc, free */
21*a28cd43dSSascha Wildner #include <stdio.h> /* fprintf */
22*a28cd43dSSascha Wildner #include <time.h> /* clock_t, clock, CLOCKS_PER_SEC, nanosleep */
23*a28cd43dSSascha Wildner #include <errno.h>
24*a28cd43dSSascha Wildner #include <assert.h>
25*a28cd43dSSascha Wildner
26*a28cd43dSSascha Wildner #if defined(_WIN32)
27*a28cd43dSSascha Wildner # include <sys/utime.h> /* utime */
28*a28cd43dSSascha Wildner # include <io.h> /* _chmod */
29*a28cd43dSSascha Wildner #else
30*a28cd43dSSascha Wildner # include <unistd.h> /* chown, stat */
31*a28cd43dSSascha Wildner # if PLATFORM_POSIX_VERSION < 200809L || !defined(st_mtime)
32*a28cd43dSSascha Wildner # include <utime.h> /* utime */
33*a28cd43dSSascha Wildner # else
34*a28cd43dSSascha Wildner # include <fcntl.h> /* AT_FDCWD */
35*a28cd43dSSascha Wildner # include <sys/stat.h> /* utimensat */
36*a28cd43dSSascha Wildner # endif
37*a28cd43dSSascha Wildner #endif
38*a28cd43dSSascha Wildner
39*a28cd43dSSascha Wildner #if defined(_MSC_VER) || defined(__MINGW32__) || defined (__MSVCRT__)
40*a28cd43dSSascha Wildner #include <direct.h> /* needed for _mkdir in windows */
41*a28cd43dSSascha Wildner #endif
42*a28cd43dSSascha Wildner
43*a28cd43dSSascha Wildner #if defined(__linux__) || (PLATFORM_POSIX_VERSION >= 200112L) /* opendir, readdir require POSIX.1-2001 */
44*a28cd43dSSascha Wildner # include <dirent.h> /* opendir, readdir */
45*a28cd43dSSascha Wildner # include <string.h> /* strerror, memcpy */
46*a28cd43dSSascha Wildner #endif /* #ifdef _WIN32 */
47*a28cd43dSSascha Wildner
48*a28cd43dSSascha Wildner /*-****************************************
49*a28cd43dSSascha Wildner * Internal Macros
50*a28cd43dSSascha Wildner ******************************************/
51*a28cd43dSSascha Wildner
52*a28cd43dSSascha Wildner /* CONTROL is almost like an assert(), but is never disabled.
53*a28cd43dSSascha Wildner * It's designed for failures that may happen rarely,
54*a28cd43dSSascha Wildner * but we don't want to maintain a specific error code path for them,
55*a28cd43dSSascha Wildner * such as a malloc() returning NULL for example.
56*a28cd43dSSascha Wildner * Since it's always active, this macro can trigger side effects.
57*a28cd43dSSascha Wildner */
58*a28cd43dSSascha Wildner #define CONTROL(c) { \
59*a28cd43dSSascha Wildner if (!(c)) { \
60*a28cd43dSSascha Wildner UTIL_DISPLAYLEVEL(1, "Error : %s, %i : %s", \
61*a28cd43dSSascha Wildner __FILE__, __LINE__, #c); \
62*a28cd43dSSascha Wildner exit(1); \
63*a28cd43dSSascha Wildner } }
64*a28cd43dSSascha Wildner
65*a28cd43dSSascha Wildner /* console log */
66*a28cd43dSSascha Wildner #define UTIL_DISPLAY(...) fprintf(stderr, __VA_ARGS__)
67*a28cd43dSSascha Wildner #define UTIL_DISPLAYLEVEL(l, ...) { if (g_utilDisplayLevel>=l) { UTIL_DISPLAY(__VA_ARGS__); } }
68*a28cd43dSSascha Wildner
69*a28cd43dSSascha Wildner /* A modified version of realloc().
70*a28cd43dSSascha Wildner * If UTIL_realloc() fails the original block is freed.
71*a28cd43dSSascha Wildner */
UTIL_realloc(void * ptr,size_t size)72*a28cd43dSSascha Wildner UTIL_STATIC void* UTIL_realloc(void *ptr, size_t size)
73*a28cd43dSSascha Wildner {
74*a28cd43dSSascha Wildner void *newptr = realloc(ptr, size);
75*a28cd43dSSascha Wildner if (newptr) return newptr;
76*a28cd43dSSascha Wildner free(ptr);
77*a28cd43dSSascha Wildner return NULL;
78*a28cd43dSSascha Wildner }
79*a28cd43dSSascha Wildner
80*a28cd43dSSascha Wildner #if defined(_MSC_VER)
81*a28cd43dSSascha Wildner #define chmod _chmod
82*a28cd43dSSascha Wildner #endif
83*a28cd43dSSascha Wildner
84*a28cd43dSSascha Wildner
85*a28cd43dSSascha Wildner /*-****************************************
86*a28cd43dSSascha Wildner * Console log
87*a28cd43dSSascha Wildner ******************************************/
88*a28cd43dSSascha Wildner int g_utilDisplayLevel;
89*a28cd43dSSascha Wildner
UTIL_requireUserConfirmation(const char * prompt,const char * abortMsg,const char * acceptableLetters,int hasStdinInput)90*a28cd43dSSascha Wildner int UTIL_requireUserConfirmation(const char* prompt, const char* abortMsg,
91*a28cd43dSSascha Wildner const char* acceptableLetters, int hasStdinInput) {
92*a28cd43dSSascha Wildner int ch, result;
93*a28cd43dSSascha Wildner
94*a28cd43dSSascha Wildner if (hasStdinInput) {
95*a28cd43dSSascha Wildner UTIL_DISPLAY("stdin is an input - not proceeding.\n");
96*a28cd43dSSascha Wildner return 1;
97*a28cd43dSSascha Wildner }
98*a28cd43dSSascha Wildner
99*a28cd43dSSascha Wildner UTIL_DISPLAY("%s", prompt);
100*a28cd43dSSascha Wildner ch = getchar();
101*a28cd43dSSascha Wildner result = 0;
102*a28cd43dSSascha Wildner if (strchr(acceptableLetters, ch) == NULL) {
103*a28cd43dSSascha Wildner UTIL_DISPLAY("%s", abortMsg);
104*a28cd43dSSascha Wildner result = 1;
105*a28cd43dSSascha Wildner }
106*a28cd43dSSascha Wildner /* flush the rest */
107*a28cd43dSSascha Wildner while ((ch!=EOF) && (ch!='\n'))
108*a28cd43dSSascha Wildner ch = getchar();
109*a28cd43dSSascha Wildner return result;
110*a28cd43dSSascha Wildner }
111*a28cd43dSSascha Wildner
112*a28cd43dSSascha Wildner
113*a28cd43dSSascha Wildner /*-*************************************
114*a28cd43dSSascha Wildner * Constants
115*a28cd43dSSascha Wildner ***************************************/
116*a28cd43dSSascha Wildner #define LIST_SIZE_INCREASE (8*1024)
117*a28cd43dSSascha Wildner #define MAX_FILE_OF_FILE_NAMES_SIZE (1<<20)*50
118*a28cd43dSSascha Wildner
119*a28cd43dSSascha Wildner
120*a28cd43dSSascha Wildner /*-*************************************
121*a28cd43dSSascha Wildner * Functions
122*a28cd43dSSascha Wildner ***************************************/
123*a28cd43dSSascha Wildner
UTIL_stat(const char * filename,stat_t * statbuf)124*a28cd43dSSascha Wildner int UTIL_stat(const char* filename, stat_t* statbuf)
125*a28cd43dSSascha Wildner {
126*a28cd43dSSascha Wildner #if defined(_MSC_VER)
127*a28cd43dSSascha Wildner return !_stat64(filename, statbuf);
128*a28cd43dSSascha Wildner #elif defined(__MINGW32__) && defined (__MSVCRT__)
129*a28cd43dSSascha Wildner return !_stati64(filename, statbuf);
130*a28cd43dSSascha Wildner #else
131*a28cd43dSSascha Wildner return !stat(filename, statbuf);
132*a28cd43dSSascha Wildner #endif
133*a28cd43dSSascha Wildner }
134*a28cd43dSSascha Wildner
UTIL_isRegularFile(const char * infilename)135*a28cd43dSSascha Wildner int UTIL_isRegularFile(const char* infilename)
136*a28cd43dSSascha Wildner {
137*a28cd43dSSascha Wildner stat_t statbuf;
138*a28cd43dSSascha Wildner return UTIL_stat(infilename, &statbuf) && UTIL_isRegularFileStat(&statbuf);
139*a28cd43dSSascha Wildner }
140*a28cd43dSSascha Wildner
UTIL_isRegularFileStat(const stat_t * statbuf)141*a28cd43dSSascha Wildner int UTIL_isRegularFileStat(const stat_t* statbuf)
142*a28cd43dSSascha Wildner {
143*a28cd43dSSascha Wildner #if defined(_MSC_VER)
144*a28cd43dSSascha Wildner return (statbuf->st_mode & S_IFREG) != 0;
145*a28cd43dSSascha Wildner #else
146*a28cd43dSSascha Wildner return S_ISREG(statbuf->st_mode) != 0;
147*a28cd43dSSascha Wildner #endif
148*a28cd43dSSascha Wildner }
149*a28cd43dSSascha Wildner
150*a28cd43dSSascha Wildner /* like chmod, but avoid changing permission of /dev/null */
UTIL_chmod(char const * filename,const stat_t * statbuf,mode_t permissions)151*a28cd43dSSascha Wildner int UTIL_chmod(char const* filename, const stat_t* statbuf, mode_t permissions)
152*a28cd43dSSascha Wildner {
153*a28cd43dSSascha Wildner stat_t localStatBuf;
154*a28cd43dSSascha Wildner if (statbuf == NULL) {
155*a28cd43dSSascha Wildner if (!UTIL_stat(filename, &localStatBuf)) return 0;
156*a28cd43dSSascha Wildner statbuf = &localStatBuf;
157*a28cd43dSSascha Wildner }
158*a28cd43dSSascha Wildner if (!UTIL_isRegularFileStat(statbuf)) return 0; /* pretend success, but don't change anything */
159*a28cd43dSSascha Wildner return chmod(filename, permissions);
160*a28cd43dSSascha Wildner }
161*a28cd43dSSascha Wildner
UTIL_setFileStat(const char * filename,const stat_t * statbuf)162*a28cd43dSSascha Wildner int UTIL_setFileStat(const char *filename, const stat_t *statbuf)
163*a28cd43dSSascha Wildner {
164*a28cd43dSSascha Wildner int res = 0;
165*a28cd43dSSascha Wildner
166*a28cd43dSSascha Wildner stat_t curStatBuf;
167*a28cd43dSSascha Wildner if (!UTIL_stat(filename, &curStatBuf) || !UTIL_isRegularFileStat(&curStatBuf))
168*a28cd43dSSascha Wildner return -1;
169*a28cd43dSSascha Wildner
170*a28cd43dSSascha Wildner /* set access and modification times */
171*a28cd43dSSascha Wildner /* We check that st_mtime is a macro here in order to give us confidence
172*a28cd43dSSascha Wildner * that struct stat has a struct timespec st_mtim member. We need this
173*a28cd43dSSascha Wildner * check because there are some platforms that claim to be POSIX 2008
174*a28cd43dSSascha Wildner * compliant but which do not have st_mtim... */
175*a28cd43dSSascha Wildner #if (PLATFORM_POSIX_VERSION >= 200809L) && defined(st_mtime)
176*a28cd43dSSascha Wildner {
177*a28cd43dSSascha Wildner /* (atime, mtime) */
178*a28cd43dSSascha Wildner struct timespec timebuf[2] = { {0, UTIME_NOW} };
179*a28cd43dSSascha Wildner timebuf[1] = statbuf->st_mtim;
180*a28cd43dSSascha Wildner res += utimensat(AT_FDCWD, filename, timebuf, 0);
181*a28cd43dSSascha Wildner }
182*a28cd43dSSascha Wildner #else
183*a28cd43dSSascha Wildner {
184*a28cd43dSSascha Wildner struct utimbuf timebuf;
185*a28cd43dSSascha Wildner timebuf.actime = time(NULL);
186*a28cd43dSSascha Wildner timebuf.modtime = statbuf->st_mtime;
187*a28cd43dSSascha Wildner res += utime(filename, &timebuf);
188*a28cd43dSSascha Wildner }
189*a28cd43dSSascha Wildner #endif
190*a28cd43dSSascha Wildner
191*a28cd43dSSascha Wildner #if !defined(_WIN32)
192*a28cd43dSSascha Wildner res += chown(filename, statbuf->st_uid, statbuf->st_gid); /* Copy ownership */
193*a28cd43dSSascha Wildner #endif
194*a28cd43dSSascha Wildner
195*a28cd43dSSascha Wildner res += UTIL_chmod(filename, &curStatBuf, statbuf->st_mode & 07777); /* Copy file permissions */
196*a28cd43dSSascha Wildner
197*a28cd43dSSascha Wildner errno = 0;
198*a28cd43dSSascha Wildner return -res; /* number of errors is returned */
199*a28cd43dSSascha Wildner }
200*a28cd43dSSascha Wildner
UTIL_isDirectory(const char * infilename)201*a28cd43dSSascha Wildner int UTIL_isDirectory(const char* infilename)
202*a28cd43dSSascha Wildner {
203*a28cd43dSSascha Wildner stat_t statbuf;
204*a28cd43dSSascha Wildner return UTIL_stat(infilename, &statbuf) && UTIL_isDirectoryStat(&statbuf);
205*a28cd43dSSascha Wildner }
206*a28cd43dSSascha Wildner
UTIL_isDirectoryStat(const stat_t * statbuf)207*a28cd43dSSascha Wildner int UTIL_isDirectoryStat(const stat_t* statbuf)
208*a28cd43dSSascha Wildner {
209*a28cd43dSSascha Wildner #if defined(_MSC_VER)
210*a28cd43dSSascha Wildner return (statbuf->st_mode & _S_IFDIR) != 0;
211*a28cd43dSSascha Wildner #else
212*a28cd43dSSascha Wildner return S_ISDIR(statbuf->st_mode) != 0;
213*a28cd43dSSascha Wildner #endif
214*a28cd43dSSascha Wildner }
215*a28cd43dSSascha Wildner
UTIL_compareStr(const void * p1,const void * p2)216*a28cd43dSSascha Wildner int UTIL_compareStr(const void *p1, const void *p2) {
217*a28cd43dSSascha Wildner return strcmp(* (char * const *) p1, * (char * const *) p2);
218*a28cd43dSSascha Wildner }
219*a28cd43dSSascha Wildner
UTIL_isSameFile(const char * fName1,const char * fName2)220*a28cd43dSSascha Wildner int UTIL_isSameFile(const char* fName1, const char* fName2)
221*a28cd43dSSascha Wildner {
222*a28cd43dSSascha Wildner assert(fName1 != NULL); assert(fName2 != NULL);
223*a28cd43dSSascha Wildner #if defined(_MSC_VER) || defined(_WIN32)
224*a28cd43dSSascha Wildner /* note : Visual does not support file identification by inode.
225*a28cd43dSSascha Wildner * inode does not work on Windows, even with a posix layer, like msys2.
226*a28cd43dSSascha Wildner * The following work-around is limited to detecting exact name repetition only,
227*a28cd43dSSascha Wildner * aka `filename` is considered different from `subdir/../filename` */
228*a28cd43dSSascha Wildner return !strcmp(fName1, fName2);
229*a28cd43dSSascha Wildner #else
230*a28cd43dSSascha Wildner { stat_t file1Stat;
231*a28cd43dSSascha Wildner stat_t file2Stat;
232*a28cd43dSSascha Wildner return UTIL_stat(fName1, &file1Stat)
233*a28cd43dSSascha Wildner && UTIL_stat(fName2, &file2Stat)
234*a28cd43dSSascha Wildner && (file1Stat.st_dev == file2Stat.st_dev)
235*a28cd43dSSascha Wildner && (file1Stat.st_ino == file2Stat.st_ino);
236*a28cd43dSSascha Wildner }
237*a28cd43dSSascha Wildner #endif
238*a28cd43dSSascha Wildner }
239*a28cd43dSSascha Wildner
240*a28cd43dSSascha Wildner /* UTIL_isFIFO : distinguish named pipes */
UTIL_isFIFO(const char * infilename)241*a28cd43dSSascha Wildner int UTIL_isFIFO(const char* infilename)
242*a28cd43dSSascha Wildner {
243*a28cd43dSSascha Wildner /* macro guards, as defined in : https://linux.die.net/man/2/lstat */
244*a28cd43dSSascha Wildner #if PLATFORM_POSIX_VERSION >= 200112L
245*a28cd43dSSascha Wildner stat_t statbuf;
246*a28cd43dSSascha Wildner if (UTIL_stat(infilename, &statbuf) && UTIL_isFIFOStat(&statbuf)) return 1;
247*a28cd43dSSascha Wildner #endif
248*a28cd43dSSascha Wildner (void)infilename;
249*a28cd43dSSascha Wildner return 0;
250*a28cd43dSSascha Wildner }
251*a28cd43dSSascha Wildner
252*a28cd43dSSascha Wildner /* UTIL_isFIFO : distinguish named pipes */
UTIL_isFIFOStat(const stat_t * statbuf)253*a28cd43dSSascha Wildner int UTIL_isFIFOStat(const stat_t* statbuf)
254*a28cd43dSSascha Wildner {
255*a28cd43dSSascha Wildner /* macro guards, as defined in : https://linux.die.net/man/2/lstat */
256*a28cd43dSSascha Wildner #if PLATFORM_POSIX_VERSION >= 200112L
257*a28cd43dSSascha Wildner if (S_ISFIFO(statbuf->st_mode)) return 1;
258*a28cd43dSSascha Wildner #endif
259*a28cd43dSSascha Wildner (void)statbuf;
260*a28cd43dSSascha Wildner return 0;
261*a28cd43dSSascha Wildner }
262*a28cd43dSSascha Wildner
UTIL_isLink(const char * infilename)263*a28cd43dSSascha Wildner int UTIL_isLink(const char* infilename)
264*a28cd43dSSascha Wildner {
265*a28cd43dSSascha Wildner /* macro guards, as defined in : https://linux.die.net/man/2/lstat */
266*a28cd43dSSascha Wildner #if PLATFORM_POSIX_VERSION >= 200112L
267*a28cd43dSSascha Wildner stat_t statbuf;
268*a28cd43dSSascha Wildner int const r = lstat(infilename, &statbuf);
269*a28cd43dSSascha Wildner if (!r && S_ISLNK(statbuf.st_mode)) return 1;
270*a28cd43dSSascha Wildner #endif
271*a28cd43dSSascha Wildner (void)infilename;
272*a28cd43dSSascha Wildner return 0;
273*a28cd43dSSascha Wildner }
274*a28cd43dSSascha Wildner
UTIL_getFileSize(const char * infilename)275*a28cd43dSSascha Wildner U64 UTIL_getFileSize(const char* infilename)
276*a28cd43dSSascha Wildner {
277*a28cd43dSSascha Wildner stat_t statbuf;
278*a28cd43dSSascha Wildner if (!UTIL_stat(infilename, &statbuf)) return UTIL_FILESIZE_UNKNOWN;
279*a28cd43dSSascha Wildner return UTIL_getFileSizeStat(&statbuf);
280*a28cd43dSSascha Wildner }
281*a28cd43dSSascha Wildner
UTIL_getFileSizeStat(const stat_t * statbuf)282*a28cd43dSSascha Wildner U64 UTIL_getFileSizeStat(const stat_t* statbuf)
283*a28cd43dSSascha Wildner {
284*a28cd43dSSascha Wildner if (!UTIL_isRegularFileStat(statbuf)) return UTIL_FILESIZE_UNKNOWN;
285*a28cd43dSSascha Wildner #if defined(_MSC_VER)
286*a28cd43dSSascha Wildner if (!(statbuf->st_mode & S_IFREG)) return UTIL_FILESIZE_UNKNOWN;
287*a28cd43dSSascha Wildner #elif defined(__MINGW32__) && defined (__MSVCRT__)
288*a28cd43dSSascha Wildner if (!(statbuf->st_mode & S_IFREG)) return UTIL_FILESIZE_UNKNOWN;
289*a28cd43dSSascha Wildner #else
290*a28cd43dSSascha Wildner if (!S_ISREG(statbuf->st_mode)) return UTIL_FILESIZE_UNKNOWN;
291*a28cd43dSSascha Wildner #endif
292*a28cd43dSSascha Wildner return (U64)statbuf->st_size;
293*a28cd43dSSascha Wildner }
294*a28cd43dSSascha Wildner
295*a28cd43dSSascha Wildner
UTIL_getTotalFileSize(const char * const * fileNamesTable,unsigned nbFiles)296*a28cd43dSSascha Wildner U64 UTIL_getTotalFileSize(const char* const * fileNamesTable, unsigned nbFiles)
297*a28cd43dSSascha Wildner {
298*a28cd43dSSascha Wildner U64 total = 0;
299*a28cd43dSSascha Wildner unsigned n;
300*a28cd43dSSascha Wildner for (n=0; n<nbFiles; n++) {
301*a28cd43dSSascha Wildner U64 const size = UTIL_getFileSize(fileNamesTable[n]);
302*a28cd43dSSascha Wildner if (size == UTIL_FILESIZE_UNKNOWN) return UTIL_FILESIZE_UNKNOWN;
303*a28cd43dSSascha Wildner total += size;
304*a28cd43dSSascha Wildner }
305*a28cd43dSSascha Wildner return total;
306*a28cd43dSSascha Wildner }
307*a28cd43dSSascha Wildner
308*a28cd43dSSascha Wildner
309*a28cd43dSSascha Wildner /* condition : @file must be valid, and not have reached its end.
310*a28cd43dSSascha Wildner * @return : length of line written into @buf, ended with `\0` instead of '\n',
311*a28cd43dSSascha Wildner * or 0, if there is no new line */
readLineFromFile(char * buf,size_t len,FILE * file)312*a28cd43dSSascha Wildner static size_t readLineFromFile(char* buf, size_t len, FILE* file)
313*a28cd43dSSascha Wildner {
314*a28cd43dSSascha Wildner assert(!feof(file));
315*a28cd43dSSascha Wildner /* Work around Cygwin problem when len == 1 it returns NULL. */
316*a28cd43dSSascha Wildner if (len <= 1) return 0;
317*a28cd43dSSascha Wildner CONTROL( fgets(buf, (int) len, file) );
318*a28cd43dSSascha Wildner { size_t linelen = strlen(buf);
319*a28cd43dSSascha Wildner if (strlen(buf)==0) return 0;
320*a28cd43dSSascha Wildner if (buf[linelen-1] == '\n') linelen--;
321*a28cd43dSSascha Wildner buf[linelen] = '\0';
322*a28cd43dSSascha Wildner return linelen+1;
323*a28cd43dSSascha Wildner }
324*a28cd43dSSascha Wildner }
325*a28cd43dSSascha Wildner
326*a28cd43dSSascha Wildner /* Conditions :
327*a28cd43dSSascha Wildner * size of @inputFileName file must be < @dstCapacity
328*a28cd43dSSascha Wildner * @dst must be initialized
329*a28cd43dSSascha Wildner * @return : nb of lines
330*a28cd43dSSascha Wildner * or -1 if there's an error
331*a28cd43dSSascha Wildner */
332*a28cd43dSSascha Wildner static int
readLinesFromFile(void * dst,size_t dstCapacity,const char * inputFileName)333*a28cd43dSSascha Wildner readLinesFromFile(void* dst, size_t dstCapacity,
334*a28cd43dSSascha Wildner const char* inputFileName)
335*a28cd43dSSascha Wildner {
336*a28cd43dSSascha Wildner int nbFiles = 0;
337*a28cd43dSSascha Wildner size_t pos = 0;
338*a28cd43dSSascha Wildner char* const buf = (char*)dst;
339*a28cd43dSSascha Wildner FILE* const inputFile = fopen(inputFileName, "r");
340*a28cd43dSSascha Wildner
341*a28cd43dSSascha Wildner assert(dst != NULL);
342*a28cd43dSSascha Wildner
343*a28cd43dSSascha Wildner if(!inputFile) {
344*a28cd43dSSascha Wildner if (g_utilDisplayLevel >= 1) perror("zstd:util:readLinesFromFile");
345*a28cd43dSSascha Wildner return -1;
346*a28cd43dSSascha Wildner }
347*a28cd43dSSascha Wildner
348*a28cd43dSSascha Wildner while ( !feof(inputFile) ) {
349*a28cd43dSSascha Wildner size_t const lineLength = readLineFromFile(buf+pos, dstCapacity-pos, inputFile);
350*a28cd43dSSascha Wildner if (lineLength == 0) break;
351*a28cd43dSSascha Wildner assert(pos + lineLength < dstCapacity);
352*a28cd43dSSascha Wildner pos += lineLength;
353*a28cd43dSSascha Wildner ++nbFiles;
354*a28cd43dSSascha Wildner }
355*a28cd43dSSascha Wildner
356*a28cd43dSSascha Wildner CONTROL( fclose(inputFile) == 0 );
357*a28cd43dSSascha Wildner
358*a28cd43dSSascha Wildner return nbFiles;
359*a28cd43dSSascha Wildner }
360*a28cd43dSSascha Wildner
361*a28cd43dSSascha Wildner /*Note: buf is not freed in case function successfully created table because filesTable->fileNames[0] = buf*/
362*a28cd43dSSascha Wildner FileNamesTable*
UTIL_createFileNamesTable_fromFileName(const char * inputFileName)363*a28cd43dSSascha Wildner UTIL_createFileNamesTable_fromFileName(const char* inputFileName)
364*a28cd43dSSascha Wildner {
365*a28cd43dSSascha Wildner size_t nbFiles = 0;
366*a28cd43dSSascha Wildner char* buf;
367*a28cd43dSSascha Wildner size_t bufSize;
368*a28cd43dSSascha Wildner size_t pos = 0;
369*a28cd43dSSascha Wildner stat_t statbuf;
370*a28cd43dSSascha Wildner
371*a28cd43dSSascha Wildner if (!UTIL_stat(inputFileName, &statbuf) || !UTIL_isRegularFileStat(&statbuf))
372*a28cd43dSSascha Wildner return NULL;
373*a28cd43dSSascha Wildner
374*a28cd43dSSascha Wildner { U64 const inputFileSize = UTIL_getFileSizeStat(&statbuf);
375*a28cd43dSSascha Wildner if(inputFileSize > MAX_FILE_OF_FILE_NAMES_SIZE)
376*a28cd43dSSascha Wildner return NULL;
377*a28cd43dSSascha Wildner bufSize = (size_t)(inputFileSize + 1); /* (+1) to add '\0' at the end of last filename */
378*a28cd43dSSascha Wildner }
379*a28cd43dSSascha Wildner
380*a28cd43dSSascha Wildner buf = (char*) malloc(bufSize);
381*a28cd43dSSascha Wildner CONTROL( buf != NULL );
382*a28cd43dSSascha Wildner
383*a28cd43dSSascha Wildner { int const ret_nbFiles = readLinesFromFile(buf, bufSize, inputFileName);
384*a28cd43dSSascha Wildner
385*a28cd43dSSascha Wildner if (ret_nbFiles <= 0) {
386*a28cd43dSSascha Wildner free(buf);
387*a28cd43dSSascha Wildner return NULL;
388*a28cd43dSSascha Wildner }
389*a28cd43dSSascha Wildner nbFiles = (size_t)ret_nbFiles;
390*a28cd43dSSascha Wildner }
391*a28cd43dSSascha Wildner
392*a28cd43dSSascha Wildner { const char** filenamesTable = (const char**) malloc(nbFiles * sizeof(*filenamesTable));
393*a28cd43dSSascha Wildner CONTROL(filenamesTable != NULL);
394*a28cd43dSSascha Wildner
395*a28cd43dSSascha Wildner { size_t fnb;
396*a28cd43dSSascha Wildner for (fnb = 0, pos = 0; fnb < nbFiles; fnb++) {
397*a28cd43dSSascha Wildner filenamesTable[fnb] = buf+pos;
398*a28cd43dSSascha Wildner pos += strlen(buf+pos)+1; /* +1 for the finishing `\0` */
399*a28cd43dSSascha Wildner } }
400*a28cd43dSSascha Wildner assert(pos <= bufSize);
401*a28cd43dSSascha Wildner
402*a28cd43dSSascha Wildner return UTIL_assembleFileNamesTable(filenamesTable, nbFiles, buf);
403*a28cd43dSSascha Wildner }
404*a28cd43dSSascha Wildner }
405*a28cd43dSSascha Wildner
406*a28cd43dSSascha Wildner static FileNamesTable*
UTIL_assembleFileNamesTable2(const char ** filenames,size_t tableSize,size_t tableCapacity,char * buf)407*a28cd43dSSascha Wildner UTIL_assembleFileNamesTable2(const char** filenames, size_t tableSize, size_t tableCapacity, char* buf)
408*a28cd43dSSascha Wildner {
409*a28cd43dSSascha Wildner FileNamesTable* const table = (FileNamesTable*) malloc(sizeof(*table));
410*a28cd43dSSascha Wildner CONTROL(table != NULL);
411*a28cd43dSSascha Wildner table->fileNames = filenames;
412*a28cd43dSSascha Wildner table->buf = buf;
413*a28cd43dSSascha Wildner table->tableSize = tableSize;
414*a28cd43dSSascha Wildner table->tableCapacity = tableCapacity;
415*a28cd43dSSascha Wildner return table;
416*a28cd43dSSascha Wildner }
417*a28cd43dSSascha Wildner
418*a28cd43dSSascha Wildner FileNamesTable*
UTIL_assembleFileNamesTable(const char ** filenames,size_t tableSize,char * buf)419*a28cd43dSSascha Wildner UTIL_assembleFileNamesTable(const char** filenames, size_t tableSize, char* buf)
420*a28cd43dSSascha Wildner {
421*a28cd43dSSascha Wildner return UTIL_assembleFileNamesTable2(filenames, tableSize, tableSize, buf);
422*a28cd43dSSascha Wildner }
423*a28cd43dSSascha Wildner
UTIL_freeFileNamesTable(FileNamesTable * table)424*a28cd43dSSascha Wildner void UTIL_freeFileNamesTable(FileNamesTable* table)
425*a28cd43dSSascha Wildner {
426*a28cd43dSSascha Wildner if (table==NULL) return;
427*a28cd43dSSascha Wildner free((void*)table->fileNames);
428*a28cd43dSSascha Wildner free(table->buf);
429*a28cd43dSSascha Wildner free(table);
430*a28cd43dSSascha Wildner }
431*a28cd43dSSascha Wildner
UTIL_allocateFileNamesTable(size_t tableSize)432*a28cd43dSSascha Wildner FileNamesTable* UTIL_allocateFileNamesTable(size_t tableSize)
433*a28cd43dSSascha Wildner {
434*a28cd43dSSascha Wildner const char** const fnTable = (const char**)malloc(tableSize * sizeof(*fnTable));
435*a28cd43dSSascha Wildner FileNamesTable* fnt;
436*a28cd43dSSascha Wildner if (fnTable==NULL) return NULL;
437*a28cd43dSSascha Wildner fnt = UTIL_assembleFileNamesTable(fnTable, tableSize, NULL);
438*a28cd43dSSascha Wildner fnt->tableSize = 0; /* the table is empty */
439*a28cd43dSSascha Wildner return fnt;
440*a28cd43dSSascha Wildner }
441*a28cd43dSSascha Wildner
UTIL_refFilename(FileNamesTable * fnt,const char * filename)442*a28cd43dSSascha Wildner void UTIL_refFilename(FileNamesTable* fnt, const char* filename)
443*a28cd43dSSascha Wildner {
444*a28cd43dSSascha Wildner assert(fnt->tableSize < fnt->tableCapacity);
445*a28cd43dSSascha Wildner fnt->fileNames[fnt->tableSize] = filename;
446*a28cd43dSSascha Wildner fnt->tableSize++;
447*a28cd43dSSascha Wildner }
448*a28cd43dSSascha Wildner
getTotalTableSize(FileNamesTable * table)449*a28cd43dSSascha Wildner static size_t getTotalTableSize(FileNamesTable* table)
450*a28cd43dSSascha Wildner {
451*a28cd43dSSascha Wildner size_t fnb = 0, totalSize = 0;
452*a28cd43dSSascha Wildner for(fnb = 0 ; fnb < table->tableSize && table->fileNames[fnb] ; ++fnb) {
453*a28cd43dSSascha Wildner totalSize += strlen(table->fileNames[fnb]) + 1; /* +1 to add '\0' at the end of each fileName */
454*a28cd43dSSascha Wildner }
455*a28cd43dSSascha Wildner return totalSize;
456*a28cd43dSSascha Wildner }
457*a28cd43dSSascha Wildner
458*a28cd43dSSascha Wildner FileNamesTable*
UTIL_mergeFileNamesTable(FileNamesTable * table1,FileNamesTable * table2)459*a28cd43dSSascha Wildner UTIL_mergeFileNamesTable(FileNamesTable* table1, FileNamesTable* table2)
460*a28cd43dSSascha Wildner {
461*a28cd43dSSascha Wildner unsigned newTableIdx = 0;
462*a28cd43dSSascha Wildner size_t pos = 0;
463*a28cd43dSSascha Wildner size_t newTotalTableSize;
464*a28cd43dSSascha Wildner char* buf;
465*a28cd43dSSascha Wildner
466*a28cd43dSSascha Wildner FileNamesTable* const newTable = UTIL_assembleFileNamesTable(NULL, 0, NULL);
467*a28cd43dSSascha Wildner CONTROL( newTable != NULL );
468*a28cd43dSSascha Wildner
469*a28cd43dSSascha Wildner newTotalTableSize = getTotalTableSize(table1) + getTotalTableSize(table2);
470*a28cd43dSSascha Wildner
471*a28cd43dSSascha Wildner buf = (char*) calloc(newTotalTableSize, sizeof(*buf));
472*a28cd43dSSascha Wildner CONTROL ( buf != NULL );
473*a28cd43dSSascha Wildner
474*a28cd43dSSascha Wildner newTable->buf = buf;
475*a28cd43dSSascha Wildner newTable->tableSize = table1->tableSize + table2->tableSize;
476*a28cd43dSSascha Wildner newTable->fileNames = (const char **) calloc(newTable->tableSize, sizeof(*(newTable->fileNames)));
477*a28cd43dSSascha Wildner CONTROL ( newTable->fileNames != NULL );
478*a28cd43dSSascha Wildner
479*a28cd43dSSascha Wildner { unsigned idx1;
480*a28cd43dSSascha Wildner for( idx1=0 ; (idx1 < table1->tableSize) && table1->fileNames[idx1] && (pos < newTotalTableSize); ++idx1, ++newTableIdx) {
481*a28cd43dSSascha Wildner size_t const curLen = strlen(table1->fileNames[idx1]);
482*a28cd43dSSascha Wildner memcpy(buf+pos, table1->fileNames[idx1], curLen);
483*a28cd43dSSascha Wildner assert(newTableIdx <= newTable->tableSize);
484*a28cd43dSSascha Wildner newTable->fileNames[newTableIdx] = buf+pos;
485*a28cd43dSSascha Wildner pos += curLen+1;
486*a28cd43dSSascha Wildner } }
487*a28cd43dSSascha Wildner
488*a28cd43dSSascha Wildner { unsigned idx2;
489*a28cd43dSSascha Wildner for( idx2=0 ; (idx2 < table2->tableSize) && table2->fileNames[idx2] && (pos < newTotalTableSize) ; ++idx2, ++newTableIdx) {
490*a28cd43dSSascha Wildner size_t const curLen = strlen(table2->fileNames[idx2]);
491*a28cd43dSSascha Wildner memcpy(buf+pos, table2->fileNames[idx2], curLen);
492*a28cd43dSSascha Wildner assert(newTableIdx <= newTable->tableSize);
493*a28cd43dSSascha Wildner newTable->fileNames[newTableIdx] = buf+pos;
494*a28cd43dSSascha Wildner pos += curLen+1;
495*a28cd43dSSascha Wildner } }
496*a28cd43dSSascha Wildner assert(pos <= newTotalTableSize);
497*a28cd43dSSascha Wildner newTable->tableSize = newTableIdx;
498*a28cd43dSSascha Wildner
499*a28cd43dSSascha Wildner UTIL_freeFileNamesTable(table1);
500*a28cd43dSSascha Wildner UTIL_freeFileNamesTable(table2);
501*a28cd43dSSascha Wildner
502*a28cd43dSSascha Wildner return newTable;
503*a28cd43dSSascha Wildner }
504*a28cd43dSSascha Wildner
505*a28cd43dSSascha Wildner #ifdef _WIN32
UTIL_prepareFileList(const char * dirName,char ** bufStart,size_t * pos,char ** bufEnd,int followLinks)506*a28cd43dSSascha Wildner static int UTIL_prepareFileList(const char* dirName,
507*a28cd43dSSascha Wildner char** bufStart, size_t* pos,
508*a28cd43dSSascha Wildner char** bufEnd, int followLinks)
509*a28cd43dSSascha Wildner {
510*a28cd43dSSascha Wildner char* path;
511*a28cd43dSSascha Wildner size_t dirLength, pathLength;
512*a28cd43dSSascha Wildner int nbFiles = 0;
513*a28cd43dSSascha Wildner WIN32_FIND_DATAA cFile;
514*a28cd43dSSascha Wildner HANDLE hFile;
515*a28cd43dSSascha Wildner
516*a28cd43dSSascha Wildner dirLength = strlen(dirName);
517*a28cd43dSSascha Wildner path = (char*) malloc(dirLength + 3);
518*a28cd43dSSascha Wildner if (!path) return 0;
519*a28cd43dSSascha Wildner
520*a28cd43dSSascha Wildner memcpy(path, dirName, dirLength);
521*a28cd43dSSascha Wildner path[dirLength] = '\\';
522*a28cd43dSSascha Wildner path[dirLength+1] = '*';
523*a28cd43dSSascha Wildner path[dirLength+2] = 0;
524*a28cd43dSSascha Wildner
525*a28cd43dSSascha Wildner hFile=FindFirstFileA(path, &cFile);
526*a28cd43dSSascha Wildner if (hFile == INVALID_HANDLE_VALUE) {
527*a28cd43dSSascha Wildner UTIL_DISPLAYLEVEL(1, "Cannot open directory '%s'\n", dirName);
528*a28cd43dSSascha Wildner return 0;
529*a28cd43dSSascha Wildner }
530*a28cd43dSSascha Wildner free(path);
531*a28cd43dSSascha Wildner
532*a28cd43dSSascha Wildner do {
533*a28cd43dSSascha Wildner size_t const fnameLength = strlen(cFile.cFileName);
534*a28cd43dSSascha Wildner path = (char*) malloc(dirLength + fnameLength + 2);
535*a28cd43dSSascha Wildner if (!path) { FindClose(hFile); return 0; }
536*a28cd43dSSascha Wildner memcpy(path, dirName, dirLength);
537*a28cd43dSSascha Wildner path[dirLength] = '\\';
538*a28cd43dSSascha Wildner memcpy(path+dirLength+1, cFile.cFileName, fnameLength);
539*a28cd43dSSascha Wildner pathLength = dirLength+1+fnameLength;
540*a28cd43dSSascha Wildner path[pathLength] = 0;
541*a28cd43dSSascha Wildner if (cFile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
542*a28cd43dSSascha Wildner if ( strcmp (cFile.cFileName, "..") == 0
543*a28cd43dSSascha Wildner || strcmp (cFile.cFileName, ".") == 0 )
544*a28cd43dSSascha Wildner continue;
545*a28cd43dSSascha Wildner /* Recursively call "UTIL_prepareFileList" with the new path. */
546*a28cd43dSSascha Wildner nbFiles += UTIL_prepareFileList(path, bufStart, pos, bufEnd, followLinks);
547*a28cd43dSSascha Wildner if (*bufStart == NULL) { free(path); FindClose(hFile); return 0; }
548*a28cd43dSSascha Wildner } else if ( (cFile.dwFileAttributes & FILE_ATTRIBUTE_NORMAL)
549*a28cd43dSSascha Wildner || (cFile.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE)
550*a28cd43dSSascha Wildner || (cFile.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED) ) {
551*a28cd43dSSascha Wildner if (*bufStart + *pos + pathLength >= *bufEnd) {
552*a28cd43dSSascha Wildner ptrdiff_t const newListSize = (*bufEnd - *bufStart) + LIST_SIZE_INCREASE;
553*a28cd43dSSascha Wildner *bufStart = (char*)UTIL_realloc(*bufStart, newListSize);
554*a28cd43dSSascha Wildner if (*bufStart == NULL) { free(path); FindClose(hFile); return 0; }
555*a28cd43dSSascha Wildner *bufEnd = *bufStart + newListSize;
556*a28cd43dSSascha Wildner }
557*a28cd43dSSascha Wildner if (*bufStart + *pos + pathLength < *bufEnd) {
558*a28cd43dSSascha Wildner memcpy(*bufStart + *pos, path, pathLength+1 /* include final \0 */);
559*a28cd43dSSascha Wildner *pos += pathLength + 1;
560*a28cd43dSSascha Wildner nbFiles++;
561*a28cd43dSSascha Wildner } }
562*a28cd43dSSascha Wildner free(path);
563*a28cd43dSSascha Wildner } while (FindNextFileA(hFile, &cFile));
564*a28cd43dSSascha Wildner
565*a28cd43dSSascha Wildner FindClose(hFile);
566*a28cd43dSSascha Wildner return nbFiles;
567*a28cd43dSSascha Wildner }
568*a28cd43dSSascha Wildner
569*a28cd43dSSascha Wildner #elif defined(__linux__) || (PLATFORM_POSIX_VERSION >= 200112L) /* opendir, readdir require POSIX.1-2001 */
570*a28cd43dSSascha Wildner
UTIL_prepareFileList(const char * dirName,char ** bufStart,size_t * pos,char ** bufEnd,int followLinks)571*a28cd43dSSascha Wildner static int UTIL_prepareFileList(const char *dirName,
572*a28cd43dSSascha Wildner char** bufStart, size_t* pos,
573*a28cd43dSSascha Wildner char** bufEnd, int followLinks)
574*a28cd43dSSascha Wildner {
575*a28cd43dSSascha Wildner DIR* dir;
576*a28cd43dSSascha Wildner struct dirent * entry;
577*a28cd43dSSascha Wildner size_t dirLength;
578*a28cd43dSSascha Wildner int nbFiles = 0;
579*a28cd43dSSascha Wildner
580*a28cd43dSSascha Wildner if (!(dir = opendir(dirName))) {
581*a28cd43dSSascha Wildner UTIL_DISPLAYLEVEL(1, "Cannot open directory '%s': %s\n", dirName, strerror(errno));
582*a28cd43dSSascha Wildner return 0;
583*a28cd43dSSascha Wildner }
584*a28cd43dSSascha Wildner
585*a28cd43dSSascha Wildner dirLength = strlen(dirName);
586*a28cd43dSSascha Wildner errno = 0;
587*a28cd43dSSascha Wildner while ((entry = readdir(dir)) != NULL) {
588*a28cd43dSSascha Wildner char* path;
589*a28cd43dSSascha Wildner size_t fnameLength, pathLength;
590*a28cd43dSSascha Wildner if (strcmp (entry->d_name, "..") == 0 ||
591*a28cd43dSSascha Wildner strcmp (entry->d_name, ".") == 0) continue;
592*a28cd43dSSascha Wildner fnameLength = strlen(entry->d_name);
593*a28cd43dSSascha Wildner path = (char*) malloc(dirLength + fnameLength + 2);
594*a28cd43dSSascha Wildner if (!path) { closedir(dir); return 0; }
595*a28cd43dSSascha Wildner memcpy(path, dirName, dirLength);
596*a28cd43dSSascha Wildner
597*a28cd43dSSascha Wildner path[dirLength] = '/';
598*a28cd43dSSascha Wildner memcpy(path+dirLength+1, entry->d_name, fnameLength);
599*a28cd43dSSascha Wildner pathLength = dirLength+1+fnameLength;
600*a28cd43dSSascha Wildner path[pathLength] = 0;
601*a28cd43dSSascha Wildner
602*a28cd43dSSascha Wildner if (!followLinks && UTIL_isLink(path)) {
603*a28cd43dSSascha Wildner UTIL_DISPLAYLEVEL(2, "Warning : %s is a symbolic link, ignoring\n", path);
604*a28cd43dSSascha Wildner free(path);
605*a28cd43dSSascha Wildner continue;
606*a28cd43dSSascha Wildner }
607*a28cd43dSSascha Wildner
608*a28cd43dSSascha Wildner if (UTIL_isDirectory(path)) {
609*a28cd43dSSascha Wildner nbFiles += UTIL_prepareFileList(path, bufStart, pos, bufEnd, followLinks); /* Recursively call "UTIL_prepareFileList" with the new path. */
610*a28cd43dSSascha Wildner if (*bufStart == NULL) { free(path); closedir(dir); return 0; }
611*a28cd43dSSascha Wildner } else {
612*a28cd43dSSascha Wildner if (*bufStart + *pos + pathLength >= *bufEnd) {
613*a28cd43dSSascha Wildner ptrdiff_t newListSize = (*bufEnd - *bufStart) + LIST_SIZE_INCREASE;
614*a28cd43dSSascha Wildner assert(newListSize >= 0);
615*a28cd43dSSascha Wildner *bufStart = (char*)UTIL_realloc(*bufStart, (size_t)newListSize);
616*a28cd43dSSascha Wildner *bufEnd = *bufStart + newListSize;
617*a28cd43dSSascha Wildner if (*bufStart == NULL) { free(path); closedir(dir); return 0; }
618*a28cd43dSSascha Wildner }
619*a28cd43dSSascha Wildner if (*bufStart + *pos + pathLength < *bufEnd) {
620*a28cd43dSSascha Wildner memcpy(*bufStart + *pos, path, pathLength + 1); /* with final \0 */
621*a28cd43dSSascha Wildner *pos += pathLength + 1;
622*a28cd43dSSascha Wildner nbFiles++;
623*a28cd43dSSascha Wildner } }
624*a28cd43dSSascha Wildner free(path);
625*a28cd43dSSascha Wildner errno = 0; /* clear errno after UTIL_isDirectory, UTIL_prepareFileList */
626*a28cd43dSSascha Wildner }
627*a28cd43dSSascha Wildner
628*a28cd43dSSascha Wildner if (errno != 0) {
629*a28cd43dSSascha Wildner UTIL_DISPLAYLEVEL(1, "readdir(%s) error: %s \n", dirName, strerror(errno));
630*a28cd43dSSascha Wildner free(*bufStart);
631*a28cd43dSSascha Wildner *bufStart = NULL;
632*a28cd43dSSascha Wildner }
633*a28cd43dSSascha Wildner closedir(dir);
634*a28cd43dSSascha Wildner return nbFiles;
635*a28cd43dSSascha Wildner }
636*a28cd43dSSascha Wildner
637*a28cd43dSSascha Wildner #else
638*a28cd43dSSascha Wildner
UTIL_prepareFileList(const char * dirName,char ** bufStart,size_t * pos,char ** bufEnd,int followLinks)639*a28cd43dSSascha Wildner static int UTIL_prepareFileList(const char *dirName,
640*a28cd43dSSascha Wildner char** bufStart, size_t* pos,
641*a28cd43dSSascha Wildner char** bufEnd, int followLinks)
642*a28cd43dSSascha Wildner {
643*a28cd43dSSascha Wildner (void)bufStart; (void)bufEnd; (void)pos; (void)followLinks;
644*a28cd43dSSascha Wildner UTIL_DISPLAYLEVEL(1, "Directory %s ignored (compiled without _WIN32 or _POSIX_C_SOURCE) \n", dirName);
645*a28cd43dSSascha Wildner return 0;
646*a28cd43dSSascha Wildner }
647*a28cd43dSSascha Wildner
648*a28cd43dSSascha Wildner #endif /* #ifdef _WIN32 */
649*a28cd43dSSascha Wildner
UTIL_isCompressedFile(const char * inputName,const char * extensionList[])650*a28cd43dSSascha Wildner int UTIL_isCompressedFile(const char *inputName, const char *extensionList[])
651*a28cd43dSSascha Wildner {
652*a28cd43dSSascha Wildner const char* ext = UTIL_getFileExtension(inputName);
653*a28cd43dSSascha Wildner while(*extensionList!=NULL)
654*a28cd43dSSascha Wildner {
655*a28cd43dSSascha Wildner const int isCompressedExtension = strcmp(ext,*extensionList);
656*a28cd43dSSascha Wildner if(isCompressedExtension==0)
657*a28cd43dSSascha Wildner return 1;
658*a28cd43dSSascha Wildner ++extensionList;
659*a28cd43dSSascha Wildner }
660*a28cd43dSSascha Wildner return 0;
661*a28cd43dSSascha Wildner }
662*a28cd43dSSascha Wildner
663*a28cd43dSSascha Wildner /*Utility function to get file extension from file */
UTIL_getFileExtension(const char * infilename)664*a28cd43dSSascha Wildner const char* UTIL_getFileExtension(const char* infilename)
665*a28cd43dSSascha Wildner {
666*a28cd43dSSascha Wildner const char* extension = strrchr(infilename, '.');
667*a28cd43dSSascha Wildner if(!extension || extension==infilename) return "";
668*a28cd43dSSascha Wildner return extension;
669*a28cd43dSSascha Wildner }
670*a28cd43dSSascha Wildner
pathnameHas2Dots(const char * pathname)671*a28cd43dSSascha Wildner static int pathnameHas2Dots(const char *pathname)
672*a28cd43dSSascha Wildner {
673*a28cd43dSSascha Wildner return NULL != strstr(pathname, "..");
674*a28cd43dSSascha Wildner }
675*a28cd43dSSascha Wildner
isFileNameValidForMirroredOutput(const char * filename)676*a28cd43dSSascha Wildner static int isFileNameValidForMirroredOutput(const char *filename)
677*a28cd43dSSascha Wildner {
678*a28cd43dSSascha Wildner return !pathnameHas2Dots(filename);
679*a28cd43dSSascha Wildner }
680*a28cd43dSSascha Wildner
681*a28cd43dSSascha Wildner
682*a28cd43dSSascha Wildner #define DIR_DEFAULT_MODE 0755
getDirMode(const char * dirName)683*a28cd43dSSascha Wildner static mode_t getDirMode(const char *dirName)
684*a28cd43dSSascha Wildner {
685*a28cd43dSSascha Wildner stat_t st;
686*a28cd43dSSascha Wildner if (!UTIL_stat(dirName, &st)) {
687*a28cd43dSSascha Wildner UTIL_DISPLAY("zstd: failed to get DIR stats %s: %s\n", dirName, strerror(errno));
688*a28cd43dSSascha Wildner return DIR_DEFAULT_MODE;
689*a28cd43dSSascha Wildner }
690*a28cd43dSSascha Wildner if (!UTIL_isDirectoryStat(&st)) {
691*a28cd43dSSascha Wildner UTIL_DISPLAY("zstd: expected directory: %s\n", dirName);
692*a28cd43dSSascha Wildner return DIR_DEFAULT_MODE;
693*a28cd43dSSascha Wildner }
694*a28cd43dSSascha Wildner return st.st_mode;
695*a28cd43dSSascha Wildner }
696*a28cd43dSSascha Wildner
makeDir(const char * dir,mode_t mode)697*a28cd43dSSascha Wildner static int makeDir(const char *dir, mode_t mode)
698*a28cd43dSSascha Wildner {
699*a28cd43dSSascha Wildner #if defined(_MSC_VER) || defined(__MINGW32__) || defined (__MSVCRT__)
700*a28cd43dSSascha Wildner int ret = _mkdir(dir);
701*a28cd43dSSascha Wildner (void) mode;
702*a28cd43dSSascha Wildner #else
703*a28cd43dSSascha Wildner int ret = mkdir(dir, mode);
704*a28cd43dSSascha Wildner #endif
705*a28cd43dSSascha Wildner if (ret != 0) {
706*a28cd43dSSascha Wildner if (errno == EEXIST)
707*a28cd43dSSascha Wildner return 0;
708*a28cd43dSSascha Wildner UTIL_DISPLAY("zstd: failed to create DIR %s: %s\n", dir, strerror(errno));
709*a28cd43dSSascha Wildner }
710*a28cd43dSSascha Wildner return ret;
711*a28cd43dSSascha Wildner }
712*a28cd43dSSascha Wildner
713*a28cd43dSSascha Wildner /* this function requires a mutable input string */
convertPathnameToDirName(char * pathname)714*a28cd43dSSascha Wildner static void convertPathnameToDirName(char *pathname)
715*a28cd43dSSascha Wildner {
716*a28cd43dSSascha Wildner size_t len = 0;
717*a28cd43dSSascha Wildner char* pos = NULL;
718*a28cd43dSSascha Wildner /* get dir name from pathname similar to 'dirname()' */
719*a28cd43dSSascha Wildner assert(pathname != NULL);
720*a28cd43dSSascha Wildner
721*a28cd43dSSascha Wildner /* remove trailing '/' chars */
722*a28cd43dSSascha Wildner len = strlen(pathname);
723*a28cd43dSSascha Wildner assert(len > 0);
724*a28cd43dSSascha Wildner while (pathname[len] == PATH_SEP) {
725*a28cd43dSSascha Wildner pathname[len] = '\0';
726*a28cd43dSSascha Wildner len--;
727*a28cd43dSSascha Wildner }
728*a28cd43dSSascha Wildner if (len == 0) return;
729*a28cd43dSSascha Wildner
730*a28cd43dSSascha Wildner /* if input is a single file, return '.' instead. i.e.
731*a28cd43dSSascha Wildner * "xyz/abc/file.txt" => "xyz/abc"
732*a28cd43dSSascha Wildner "./file.txt" => "."
733*a28cd43dSSascha Wildner "file.txt" => "."
734*a28cd43dSSascha Wildner */
735*a28cd43dSSascha Wildner pos = strrchr(pathname, PATH_SEP);
736*a28cd43dSSascha Wildner if (pos == NULL) {
737*a28cd43dSSascha Wildner pathname[0] = '.';
738*a28cd43dSSascha Wildner pathname[1] = '\0';
739*a28cd43dSSascha Wildner } else {
740*a28cd43dSSascha Wildner *pos = '\0';
741*a28cd43dSSascha Wildner }
742*a28cd43dSSascha Wildner }
743*a28cd43dSSascha Wildner
744*a28cd43dSSascha Wildner /* pathname must be valid */
trimLeadingRootChar(const char * pathname)745*a28cd43dSSascha Wildner static const char* trimLeadingRootChar(const char *pathname)
746*a28cd43dSSascha Wildner {
747*a28cd43dSSascha Wildner assert(pathname != NULL);
748*a28cd43dSSascha Wildner if (pathname[0] == PATH_SEP)
749*a28cd43dSSascha Wildner return pathname + 1;
750*a28cd43dSSascha Wildner return pathname;
751*a28cd43dSSascha Wildner }
752*a28cd43dSSascha Wildner
753*a28cd43dSSascha Wildner /* pathname must be valid */
trimLeadingCurrentDirConst(const char * pathname)754*a28cd43dSSascha Wildner static const char* trimLeadingCurrentDirConst(const char *pathname)
755*a28cd43dSSascha Wildner {
756*a28cd43dSSascha Wildner assert(pathname != NULL);
757*a28cd43dSSascha Wildner if ((pathname[0] == '.') && (pathname[1] == PATH_SEP))
758*a28cd43dSSascha Wildner return pathname + 2;
759*a28cd43dSSascha Wildner return pathname;
760*a28cd43dSSascha Wildner }
761*a28cd43dSSascha Wildner
762*a28cd43dSSascha Wildner static char*
trimLeadingCurrentDir(char * pathname)763*a28cd43dSSascha Wildner trimLeadingCurrentDir(char *pathname)
764*a28cd43dSSascha Wildner {
765*a28cd43dSSascha Wildner /* 'union charunion' can do const-cast without compiler warning */
766*a28cd43dSSascha Wildner union charunion {
767*a28cd43dSSascha Wildner char *chr;
768*a28cd43dSSascha Wildner const char* cchr;
769*a28cd43dSSascha Wildner } ptr;
770*a28cd43dSSascha Wildner ptr.cchr = trimLeadingCurrentDirConst(pathname);
771*a28cd43dSSascha Wildner return ptr.chr;
772*a28cd43dSSascha Wildner }
773*a28cd43dSSascha Wildner
774*a28cd43dSSascha Wildner /* remove leading './' or '/' chars here */
trimPath(const char * pathname)775*a28cd43dSSascha Wildner static const char * trimPath(const char *pathname)
776*a28cd43dSSascha Wildner {
777*a28cd43dSSascha Wildner return trimLeadingRootChar(
778*a28cd43dSSascha Wildner trimLeadingCurrentDirConst(pathname));
779*a28cd43dSSascha Wildner }
780*a28cd43dSSascha Wildner
mallocAndJoin2Dir(const char * dir1,const char * dir2)781*a28cd43dSSascha Wildner static char* mallocAndJoin2Dir(const char *dir1, const char *dir2)
782*a28cd43dSSascha Wildner {
783*a28cd43dSSascha Wildner const size_t dir1Size = strlen(dir1);
784*a28cd43dSSascha Wildner const size_t dir2Size = strlen(dir2);
785*a28cd43dSSascha Wildner char *outDirBuffer, *buffer, trailingChar;
786*a28cd43dSSascha Wildner
787*a28cd43dSSascha Wildner assert(dir1 != NULL && dir2 != NULL);
788*a28cd43dSSascha Wildner outDirBuffer = (char *) malloc(dir1Size + dir2Size + 2);
789*a28cd43dSSascha Wildner CONTROL(outDirBuffer != NULL);
790*a28cd43dSSascha Wildner
791*a28cd43dSSascha Wildner memcpy(outDirBuffer, dir1, dir1Size);
792*a28cd43dSSascha Wildner outDirBuffer[dir1Size] = '\0';
793*a28cd43dSSascha Wildner
794*a28cd43dSSascha Wildner if (dir2[0] == '.')
795*a28cd43dSSascha Wildner return outDirBuffer;
796*a28cd43dSSascha Wildner
797*a28cd43dSSascha Wildner buffer = outDirBuffer + dir1Size;
798*a28cd43dSSascha Wildner trailingChar = *(buffer - 1);
799*a28cd43dSSascha Wildner if (trailingChar != PATH_SEP) {
800*a28cd43dSSascha Wildner *buffer = PATH_SEP;
801*a28cd43dSSascha Wildner buffer++;
802*a28cd43dSSascha Wildner }
803*a28cd43dSSascha Wildner memcpy(buffer, dir2, dir2Size);
804*a28cd43dSSascha Wildner buffer[dir2Size] = '\0';
805*a28cd43dSSascha Wildner
806*a28cd43dSSascha Wildner return outDirBuffer;
807*a28cd43dSSascha Wildner }
808*a28cd43dSSascha Wildner
809*a28cd43dSSascha Wildner /* this function will return NULL if input srcFileName is not valid name for mirrored output path */
UTIL_createMirroredDestDirName(const char * srcFileName,const char * outDirRootName)810*a28cd43dSSascha Wildner char* UTIL_createMirroredDestDirName(const char* srcFileName, const char* outDirRootName)
811*a28cd43dSSascha Wildner {
812*a28cd43dSSascha Wildner char* pathname = NULL;
813*a28cd43dSSascha Wildner if (!isFileNameValidForMirroredOutput(srcFileName))
814*a28cd43dSSascha Wildner return NULL;
815*a28cd43dSSascha Wildner
816*a28cd43dSSascha Wildner pathname = mallocAndJoin2Dir(outDirRootName, trimPath(srcFileName));
817*a28cd43dSSascha Wildner
818*a28cd43dSSascha Wildner convertPathnameToDirName(pathname);
819*a28cd43dSSascha Wildner return pathname;
820*a28cd43dSSascha Wildner }
821*a28cd43dSSascha Wildner
822*a28cd43dSSascha Wildner static int
mirrorSrcDir(char * srcDirName,const char * outDirName)823*a28cd43dSSascha Wildner mirrorSrcDir(char* srcDirName, const char* outDirName)
824*a28cd43dSSascha Wildner {
825*a28cd43dSSascha Wildner mode_t srcMode;
826*a28cd43dSSascha Wildner int status = 0;
827*a28cd43dSSascha Wildner char* newDir = mallocAndJoin2Dir(outDirName, trimPath(srcDirName));
828*a28cd43dSSascha Wildner if (!newDir)
829*a28cd43dSSascha Wildner return -ENOMEM;
830*a28cd43dSSascha Wildner
831*a28cd43dSSascha Wildner srcMode = getDirMode(srcDirName);
832*a28cd43dSSascha Wildner status = makeDir(newDir, srcMode);
833*a28cd43dSSascha Wildner free(newDir);
834*a28cd43dSSascha Wildner return status;
835*a28cd43dSSascha Wildner }
836*a28cd43dSSascha Wildner
837*a28cd43dSSascha Wildner static int
mirrorSrcDirRecursive(char * srcDirName,const char * outDirName)838*a28cd43dSSascha Wildner mirrorSrcDirRecursive(char* srcDirName, const char* outDirName)
839*a28cd43dSSascha Wildner {
840*a28cd43dSSascha Wildner int status = 0;
841*a28cd43dSSascha Wildner char* pp = trimLeadingCurrentDir(srcDirName);
842*a28cd43dSSascha Wildner char* sp = NULL;
843*a28cd43dSSascha Wildner
844*a28cd43dSSascha Wildner while ((sp = strchr(pp, PATH_SEP)) != NULL) {
845*a28cd43dSSascha Wildner if (sp != pp) {
846*a28cd43dSSascha Wildner *sp = '\0';
847*a28cd43dSSascha Wildner status = mirrorSrcDir(srcDirName, outDirName);
848*a28cd43dSSascha Wildner if (status != 0)
849*a28cd43dSSascha Wildner return status;
850*a28cd43dSSascha Wildner *sp = PATH_SEP;
851*a28cd43dSSascha Wildner }
852*a28cd43dSSascha Wildner pp = sp + 1;
853*a28cd43dSSascha Wildner }
854*a28cd43dSSascha Wildner status = mirrorSrcDir(srcDirName, outDirName);
855*a28cd43dSSascha Wildner return status;
856*a28cd43dSSascha Wildner }
857*a28cd43dSSascha Wildner
858*a28cd43dSSascha Wildner static void
makeMirroredDestDirsWithSameSrcDirMode(char ** srcDirNames,unsigned nbFile,const char * outDirName)859*a28cd43dSSascha Wildner makeMirroredDestDirsWithSameSrcDirMode(char** srcDirNames, unsigned nbFile, const char* outDirName)
860*a28cd43dSSascha Wildner {
861*a28cd43dSSascha Wildner unsigned int i = 0;
862*a28cd43dSSascha Wildner for (i = 0; i < nbFile; i++)
863*a28cd43dSSascha Wildner mirrorSrcDirRecursive(srcDirNames[i], outDirName);
864*a28cd43dSSascha Wildner }
865*a28cd43dSSascha Wildner
866*a28cd43dSSascha Wildner static int
firstIsParentOrSameDirOfSecond(const char * firstDir,const char * secondDir)867*a28cd43dSSascha Wildner firstIsParentOrSameDirOfSecond(const char* firstDir, const char* secondDir)
868*a28cd43dSSascha Wildner {
869*a28cd43dSSascha Wildner size_t firstDirLen = strlen(firstDir),
870*a28cd43dSSascha Wildner secondDirLen = strlen(secondDir);
871*a28cd43dSSascha Wildner return firstDirLen <= secondDirLen &&
872*a28cd43dSSascha Wildner (secondDir[firstDirLen] == PATH_SEP || secondDir[firstDirLen] == '\0') &&
873*a28cd43dSSascha Wildner 0 == strncmp(firstDir, secondDir, firstDirLen);
874*a28cd43dSSascha Wildner }
875*a28cd43dSSascha Wildner
compareDir(const void * pathname1,const void * pathname2)876*a28cd43dSSascha Wildner static int compareDir(const void* pathname1, const void* pathname2) {
877*a28cd43dSSascha Wildner /* sort it after remove the leading '/' or './'*/
878*a28cd43dSSascha Wildner const char* s1 = trimPath(*(char * const *) pathname1);
879*a28cd43dSSascha Wildner const char* s2 = trimPath(*(char * const *) pathname2);
880*a28cd43dSSascha Wildner return strcmp(s1, s2);
881*a28cd43dSSascha Wildner }
882*a28cd43dSSascha Wildner
883*a28cd43dSSascha Wildner static void
makeUniqueMirroredDestDirs(char ** srcDirNames,unsigned nbFile,const char * outDirName)884*a28cd43dSSascha Wildner makeUniqueMirroredDestDirs(char** srcDirNames, unsigned nbFile, const char* outDirName)
885*a28cd43dSSascha Wildner {
886*a28cd43dSSascha Wildner unsigned int i = 0, uniqueDirNr = 0;
887*a28cd43dSSascha Wildner char** uniqueDirNames = NULL;
888*a28cd43dSSascha Wildner
889*a28cd43dSSascha Wildner if (nbFile == 0)
890*a28cd43dSSascha Wildner return;
891*a28cd43dSSascha Wildner
892*a28cd43dSSascha Wildner uniqueDirNames = (char** ) malloc(nbFile * sizeof (char *));
893*a28cd43dSSascha Wildner CONTROL(uniqueDirNames != NULL);
894*a28cd43dSSascha Wildner
895*a28cd43dSSascha Wildner /* if dirs is "a/b/c" and "a/b/c/d", we only need call:
896*a28cd43dSSascha Wildner * we just need "a/b/c/d" */
897*a28cd43dSSascha Wildner qsort((void *)srcDirNames, nbFile, sizeof(char*), compareDir);
898*a28cd43dSSascha Wildner
899*a28cd43dSSascha Wildner uniqueDirNr = 1;
900*a28cd43dSSascha Wildner uniqueDirNames[uniqueDirNr - 1] = srcDirNames[0];
901*a28cd43dSSascha Wildner for (i = 1; i < nbFile; i++) {
902*a28cd43dSSascha Wildner char* prevDirName = srcDirNames[i - 1];
903*a28cd43dSSascha Wildner char* currDirName = srcDirNames[i];
904*a28cd43dSSascha Wildner
905*a28cd43dSSascha Wildner /* note: we alwasy compare trimmed path, i.e.:
906*a28cd43dSSascha Wildner * src dir of "./foo" and "/foo" will be both saved into:
907*a28cd43dSSascha Wildner * "outDirName/foo/" */
908*a28cd43dSSascha Wildner if (!firstIsParentOrSameDirOfSecond(trimPath(prevDirName),
909*a28cd43dSSascha Wildner trimPath(currDirName)))
910*a28cd43dSSascha Wildner uniqueDirNr++;
911*a28cd43dSSascha Wildner
912*a28cd43dSSascha Wildner /* we need maintain original src dir name instead of trimmed
913*a28cd43dSSascha Wildner * dir, so we can retrive the original src dir's mode_t */
914*a28cd43dSSascha Wildner uniqueDirNames[uniqueDirNr - 1] = currDirName;
915*a28cd43dSSascha Wildner }
916*a28cd43dSSascha Wildner
917*a28cd43dSSascha Wildner makeMirroredDestDirsWithSameSrcDirMode(uniqueDirNames, uniqueDirNr, outDirName);
918*a28cd43dSSascha Wildner
919*a28cd43dSSascha Wildner free(uniqueDirNames);
920*a28cd43dSSascha Wildner }
921*a28cd43dSSascha Wildner
922*a28cd43dSSascha Wildner static void
makeMirroredDestDirs(char ** srcFileNames,unsigned nbFile,const char * outDirName)923*a28cd43dSSascha Wildner makeMirroredDestDirs(char** srcFileNames, unsigned nbFile, const char* outDirName)
924*a28cd43dSSascha Wildner {
925*a28cd43dSSascha Wildner unsigned int i = 0;
926*a28cd43dSSascha Wildner for (i = 0; i < nbFile; ++i)
927*a28cd43dSSascha Wildner convertPathnameToDirName(srcFileNames[i]);
928*a28cd43dSSascha Wildner makeUniqueMirroredDestDirs(srcFileNames, nbFile, outDirName);
929*a28cd43dSSascha Wildner }
930*a28cd43dSSascha Wildner
UTIL_mirrorSourceFilesDirectories(const char ** inFileNames,unsigned int nbFile,const char * outDirName)931*a28cd43dSSascha Wildner void UTIL_mirrorSourceFilesDirectories(const char** inFileNames, unsigned int nbFile, const char* outDirName)
932*a28cd43dSSascha Wildner {
933*a28cd43dSSascha Wildner unsigned int i = 0, validFilenamesNr = 0;
934*a28cd43dSSascha Wildner char** srcFileNames = (char **) malloc(nbFile * sizeof (char *));
935*a28cd43dSSascha Wildner CONTROL(srcFileNames != NULL);
936*a28cd43dSSascha Wildner
937*a28cd43dSSascha Wildner /* check input filenames is valid */
938*a28cd43dSSascha Wildner for (i = 0; i < nbFile; ++i) {
939*a28cd43dSSascha Wildner if (isFileNameValidForMirroredOutput(inFileNames[i])) {
940*a28cd43dSSascha Wildner char* fname = STRDUP(inFileNames[i]);
941*a28cd43dSSascha Wildner CONTROL(fname != NULL);
942*a28cd43dSSascha Wildner srcFileNames[validFilenamesNr++] = fname;
943*a28cd43dSSascha Wildner }
944*a28cd43dSSascha Wildner }
945*a28cd43dSSascha Wildner
946*a28cd43dSSascha Wildner if (validFilenamesNr > 0) {
947*a28cd43dSSascha Wildner makeDir(outDirName, DIR_DEFAULT_MODE);
948*a28cd43dSSascha Wildner makeMirroredDestDirs(srcFileNames, validFilenamesNr, outDirName);
949*a28cd43dSSascha Wildner }
950*a28cd43dSSascha Wildner
951*a28cd43dSSascha Wildner for (i = 0; i < validFilenamesNr; i++)
952*a28cd43dSSascha Wildner free(srcFileNames[i]);
953*a28cd43dSSascha Wildner free(srcFileNames);
954*a28cd43dSSascha Wildner }
955*a28cd43dSSascha Wildner
956*a28cd43dSSascha Wildner FileNamesTable*
UTIL_createExpandedFNT(const char ** inputNames,size_t nbIfns,int followLinks)957*a28cd43dSSascha Wildner UTIL_createExpandedFNT(const char** inputNames, size_t nbIfns, int followLinks)
958*a28cd43dSSascha Wildner {
959*a28cd43dSSascha Wildner unsigned nbFiles;
960*a28cd43dSSascha Wildner char* buf = (char*)malloc(LIST_SIZE_INCREASE);
961*a28cd43dSSascha Wildner char* bufend = buf + LIST_SIZE_INCREASE;
962*a28cd43dSSascha Wildner
963*a28cd43dSSascha Wildner if (!buf) return NULL;
964*a28cd43dSSascha Wildner
965*a28cd43dSSascha Wildner { size_t ifnNb, pos;
966*a28cd43dSSascha Wildner for (ifnNb=0, pos=0, nbFiles=0; ifnNb<nbIfns; ifnNb++) {
967*a28cd43dSSascha Wildner if (!UTIL_isDirectory(inputNames[ifnNb])) {
968*a28cd43dSSascha Wildner size_t const len = strlen(inputNames[ifnNb]);
969*a28cd43dSSascha Wildner if (buf + pos + len >= bufend) {
970*a28cd43dSSascha Wildner ptrdiff_t newListSize = (bufend - buf) + LIST_SIZE_INCREASE;
971*a28cd43dSSascha Wildner assert(newListSize >= 0);
972*a28cd43dSSascha Wildner buf = (char*)UTIL_realloc(buf, (size_t)newListSize);
973*a28cd43dSSascha Wildner if (!buf) return NULL;
974*a28cd43dSSascha Wildner bufend = buf + newListSize;
975*a28cd43dSSascha Wildner }
976*a28cd43dSSascha Wildner if (buf + pos + len < bufend) {
977*a28cd43dSSascha Wildner memcpy(buf+pos, inputNames[ifnNb], len+1); /* including final \0 */
978*a28cd43dSSascha Wildner pos += len + 1;
979*a28cd43dSSascha Wildner nbFiles++;
980*a28cd43dSSascha Wildner }
981*a28cd43dSSascha Wildner } else {
982*a28cd43dSSascha Wildner nbFiles += (unsigned)UTIL_prepareFileList(inputNames[ifnNb], &buf, &pos, &bufend, followLinks);
983*a28cd43dSSascha Wildner if (buf == NULL) return NULL;
984*a28cd43dSSascha Wildner } } }
985*a28cd43dSSascha Wildner
986*a28cd43dSSascha Wildner /* note : even if nbFiles==0, function returns a valid, though empty, FileNamesTable* object */
987*a28cd43dSSascha Wildner
988*a28cd43dSSascha Wildner { size_t ifnNb, pos;
989*a28cd43dSSascha Wildner size_t const fntCapacity = nbFiles + 1; /* minimum 1, allows adding one reference, typically stdin */
990*a28cd43dSSascha Wildner const char** const fileNamesTable = (const char**)malloc(fntCapacity * sizeof(*fileNamesTable));
991*a28cd43dSSascha Wildner if (!fileNamesTable) { free(buf); return NULL; }
992*a28cd43dSSascha Wildner
993*a28cd43dSSascha Wildner for (ifnNb = 0, pos = 0; ifnNb < nbFiles; ifnNb++) {
994*a28cd43dSSascha Wildner fileNamesTable[ifnNb] = buf + pos;
995*a28cd43dSSascha Wildner if (buf + pos > bufend) { free(buf); free((void*)fileNamesTable); return NULL; }
996*a28cd43dSSascha Wildner pos += strlen(fileNamesTable[ifnNb]) + 1;
997*a28cd43dSSascha Wildner }
998*a28cd43dSSascha Wildner return UTIL_assembleFileNamesTable2(fileNamesTable, nbFiles, fntCapacity, buf);
999*a28cd43dSSascha Wildner }
1000*a28cd43dSSascha Wildner }
1001*a28cd43dSSascha Wildner
1002*a28cd43dSSascha Wildner
UTIL_expandFNT(FileNamesTable ** fnt,int followLinks)1003*a28cd43dSSascha Wildner void UTIL_expandFNT(FileNamesTable** fnt, int followLinks)
1004*a28cd43dSSascha Wildner {
1005*a28cd43dSSascha Wildner FileNamesTable* const newFNT = UTIL_createExpandedFNT((*fnt)->fileNames, (*fnt)->tableSize, followLinks);
1006*a28cd43dSSascha Wildner CONTROL(newFNT != NULL);
1007*a28cd43dSSascha Wildner UTIL_freeFileNamesTable(*fnt);
1008*a28cd43dSSascha Wildner *fnt = newFNT;
1009*a28cd43dSSascha Wildner }
1010*a28cd43dSSascha Wildner
UTIL_createFNT_fromROTable(const char ** filenames,size_t nbFilenames)1011*a28cd43dSSascha Wildner FileNamesTable* UTIL_createFNT_fromROTable(const char** filenames, size_t nbFilenames)
1012*a28cd43dSSascha Wildner {
1013*a28cd43dSSascha Wildner size_t const sizeof_FNTable = nbFilenames * sizeof(*filenames);
1014*a28cd43dSSascha Wildner const char** const newFNTable = (const char**)malloc(sizeof_FNTable);
1015*a28cd43dSSascha Wildner if (newFNTable==NULL) return NULL;
1016*a28cd43dSSascha Wildner memcpy((void*)newFNTable, filenames, sizeof_FNTable); /* void* : mitigate a Visual compiler bug or limitation */
1017*a28cd43dSSascha Wildner return UTIL_assembleFileNamesTable(newFNTable, nbFilenames, NULL);
1018*a28cd43dSSascha Wildner }
1019*a28cd43dSSascha Wildner
1020*a28cd43dSSascha Wildner
1021*a28cd43dSSascha Wildner /*-****************************************
1022*a28cd43dSSascha Wildner * count the number of physical cores
1023*a28cd43dSSascha Wildner ******************************************/
1024*a28cd43dSSascha Wildner
1025*a28cd43dSSascha Wildner #if defined(_WIN32) || defined(WIN32)
1026*a28cd43dSSascha Wildner
1027*a28cd43dSSascha Wildner #include <windows.h>
1028*a28cd43dSSascha Wildner
1029*a28cd43dSSascha Wildner typedef BOOL(WINAPI* LPFN_GLPI)(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, PDWORD);
1030*a28cd43dSSascha Wildner
UTIL_countPhysicalCores(void)1031*a28cd43dSSascha Wildner int UTIL_countPhysicalCores(void)
1032*a28cd43dSSascha Wildner {
1033*a28cd43dSSascha Wildner static int numPhysicalCores = 0;
1034*a28cd43dSSascha Wildner if (numPhysicalCores != 0) return numPhysicalCores;
1035*a28cd43dSSascha Wildner
1036*a28cd43dSSascha Wildner { LPFN_GLPI glpi;
1037*a28cd43dSSascha Wildner BOOL done = FALSE;
1038*a28cd43dSSascha Wildner PSYSTEM_LOGICAL_PROCESSOR_INFORMATION buffer = NULL;
1039*a28cd43dSSascha Wildner PSYSTEM_LOGICAL_PROCESSOR_INFORMATION ptr = NULL;
1040*a28cd43dSSascha Wildner DWORD returnLength = 0;
1041*a28cd43dSSascha Wildner size_t byteOffset = 0;
1042*a28cd43dSSascha Wildner
1043*a28cd43dSSascha Wildner #if defined(_MSC_VER)
1044*a28cd43dSSascha Wildner /* Visual Studio does not like the following cast */
1045*a28cd43dSSascha Wildner # pragma warning( disable : 4054 ) /* conversion from function ptr to data ptr */
1046*a28cd43dSSascha Wildner # pragma warning( disable : 4055 ) /* conversion from data ptr to function ptr */
1047*a28cd43dSSascha Wildner #endif
1048*a28cd43dSSascha Wildner glpi = (LPFN_GLPI)(void*)GetProcAddress(GetModuleHandle(TEXT("kernel32")),
1049*a28cd43dSSascha Wildner "GetLogicalProcessorInformation");
1050*a28cd43dSSascha Wildner
1051*a28cd43dSSascha Wildner if (glpi == NULL) {
1052*a28cd43dSSascha Wildner goto failed;
1053*a28cd43dSSascha Wildner }
1054*a28cd43dSSascha Wildner
1055*a28cd43dSSascha Wildner while(!done) {
1056*a28cd43dSSascha Wildner DWORD rc = glpi(buffer, &returnLength);
1057*a28cd43dSSascha Wildner if (FALSE == rc) {
1058*a28cd43dSSascha Wildner if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
1059*a28cd43dSSascha Wildner if (buffer)
1060*a28cd43dSSascha Wildner free(buffer);
1061*a28cd43dSSascha Wildner buffer = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)malloc(returnLength);
1062*a28cd43dSSascha Wildner
1063*a28cd43dSSascha Wildner if (buffer == NULL) {
1064*a28cd43dSSascha Wildner perror("zstd");
1065*a28cd43dSSascha Wildner exit(1);
1066*a28cd43dSSascha Wildner }
1067*a28cd43dSSascha Wildner } else {
1068*a28cd43dSSascha Wildner /* some other error */
1069*a28cd43dSSascha Wildner goto failed;
1070*a28cd43dSSascha Wildner }
1071*a28cd43dSSascha Wildner } else {
1072*a28cd43dSSascha Wildner done = TRUE;
1073*a28cd43dSSascha Wildner } }
1074*a28cd43dSSascha Wildner
1075*a28cd43dSSascha Wildner ptr = buffer;
1076*a28cd43dSSascha Wildner
1077*a28cd43dSSascha Wildner while (byteOffset + sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION) <= returnLength) {
1078*a28cd43dSSascha Wildner
1079*a28cd43dSSascha Wildner if (ptr->Relationship == RelationProcessorCore) {
1080*a28cd43dSSascha Wildner numPhysicalCores++;
1081*a28cd43dSSascha Wildner }
1082*a28cd43dSSascha Wildner
1083*a28cd43dSSascha Wildner ptr++;
1084*a28cd43dSSascha Wildner byteOffset += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
1085*a28cd43dSSascha Wildner }
1086*a28cd43dSSascha Wildner
1087*a28cd43dSSascha Wildner free(buffer);
1088*a28cd43dSSascha Wildner
1089*a28cd43dSSascha Wildner return numPhysicalCores;
1090*a28cd43dSSascha Wildner }
1091*a28cd43dSSascha Wildner
1092*a28cd43dSSascha Wildner failed:
1093*a28cd43dSSascha Wildner /* try to fall back on GetSystemInfo */
1094*a28cd43dSSascha Wildner { SYSTEM_INFO sysinfo;
1095*a28cd43dSSascha Wildner GetSystemInfo(&sysinfo);
1096*a28cd43dSSascha Wildner numPhysicalCores = sysinfo.dwNumberOfProcessors;
1097*a28cd43dSSascha Wildner if (numPhysicalCores == 0) numPhysicalCores = 1; /* just in case */
1098*a28cd43dSSascha Wildner }
1099*a28cd43dSSascha Wildner return numPhysicalCores;
1100*a28cd43dSSascha Wildner }
1101*a28cd43dSSascha Wildner
1102*a28cd43dSSascha Wildner #elif defined(__APPLE__)
1103*a28cd43dSSascha Wildner
1104*a28cd43dSSascha Wildner #include <sys/sysctl.h>
1105*a28cd43dSSascha Wildner
1106*a28cd43dSSascha Wildner /* Use apple-provided syscall
1107*a28cd43dSSascha Wildner * see: man 3 sysctl */
UTIL_countPhysicalCores(void)1108*a28cd43dSSascha Wildner int UTIL_countPhysicalCores(void)
1109*a28cd43dSSascha Wildner {
1110*a28cd43dSSascha Wildner static S32 numPhysicalCores = 0; /* apple specifies int32_t */
1111*a28cd43dSSascha Wildner if (numPhysicalCores != 0) return numPhysicalCores;
1112*a28cd43dSSascha Wildner
1113*a28cd43dSSascha Wildner { size_t size = sizeof(S32);
1114*a28cd43dSSascha Wildner int const ret = sysctlbyname("hw.physicalcpu", &numPhysicalCores, &size, NULL, 0);
1115*a28cd43dSSascha Wildner if (ret != 0) {
1116*a28cd43dSSascha Wildner if (errno == ENOENT) {
1117*a28cd43dSSascha Wildner /* entry not present, fall back on 1 */
1118*a28cd43dSSascha Wildner numPhysicalCores = 1;
1119*a28cd43dSSascha Wildner } else {
1120*a28cd43dSSascha Wildner perror("zstd: can't get number of physical cpus");
1121*a28cd43dSSascha Wildner exit(1);
1122*a28cd43dSSascha Wildner }
1123*a28cd43dSSascha Wildner }
1124*a28cd43dSSascha Wildner
1125*a28cd43dSSascha Wildner return numPhysicalCores;
1126*a28cd43dSSascha Wildner }
1127*a28cd43dSSascha Wildner }
1128*a28cd43dSSascha Wildner
1129*a28cd43dSSascha Wildner #elif defined(__linux__)
1130*a28cd43dSSascha Wildner
1131*a28cd43dSSascha Wildner /* parse /proc/cpuinfo
1132*a28cd43dSSascha Wildner * siblings / cpu cores should give hyperthreading ratio
1133*a28cd43dSSascha Wildner * otherwise fall back on sysconf */
UTIL_countPhysicalCores(void)1134*a28cd43dSSascha Wildner int UTIL_countPhysicalCores(void)
1135*a28cd43dSSascha Wildner {
1136*a28cd43dSSascha Wildner static int numPhysicalCores = 0;
1137*a28cd43dSSascha Wildner
1138*a28cd43dSSascha Wildner if (numPhysicalCores != 0) return numPhysicalCores;
1139*a28cd43dSSascha Wildner
1140*a28cd43dSSascha Wildner numPhysicalCores = (int)sysconf(_SC_NPROCESSORS_ONLN);
1141*a28cd43dSSascha Wildner if (numPhysicalCores == -1) {
1142*a28cd43dSSascha Wildner /* value not queryable, fall back on 1 */
1143*a28cd43dSSascha Wildner return numPhysicalCores = 1;
1144*a28cd43dSSascha Wildner }
1145*a28cd43dSSascha Wildner
1146*a28cd43dSSascha Wildner /* try to determine if there's hyperthreading */
1147*a28cd43dSSascha Wildner { FILE* const cpuinfo = fopen("/proc/cpuinfo", "r");
1148*a28cd43dSSascha Wildner #define BUF_SIZE 80
1149*a28cd43dSSascha Wildner char buff[BUF_SIZE];
1150*a28cd43dSSascha Wildner
1151*a28cd43dSSascha Wildner int siblings = 0;
1152*a28cd43dSSascha Wildner int cpu_cores = 0;
1153*a28cd43dSSascha Wildner int ratio = 1;
1154*a28cd43dSSascha Wildner
1155*a28cd43dSSascha Wildner if (cpuinfo == NULL) {
1156*a28cd43dSSascha Wildner /* fall back on the sysconf value */
1157*a28cd43dSSascha Wildner return numPhysicalCores;
1158*a28cd43dSSascha Wildner }
1159*a28cd43dSSascha Wildner
1160*a28cd43dSSascha Wildner /* assume the cpu cores/siblings values will be constant across all
1161*a28cd43dSSascha Wildner * present processors */
1162*a28cd43dSSascha Wildner while (!feof(cpuinfo)) {
1163*a28cd43dSSascha Wildner if (fgets(buff, BUF_SIZE, cpuinfo) != NULL) {
1164*a28cd43dSSascha Wildner if (strncmp(buff, "siblings", 8) == 0) {
1165*a28cd43dSSascha Wildner const char* const sep = strchr(buff, ':');
1166*a28cd43dSSascha Wildner if (sep == NULL || *sep == '\0') {
1167*a28cd43dSSascha Wildner /* formatting was broken? */
1168*a28cd43dSSascha Wildner goto failed;
1169*a28cd43dSSascha Wildner }
1170*a28cd43dSSascha Wildner
1171*a28cd43dSSascha Wildner siblings = atoi(sep + 1);
1172*a28cd43dSSascha Wildner }
1173*a28cd43dSSascha Wildner if (strncmp(buff, "cpu cores", 9) == 0) {
1174*a28cd43dSSascha Wildner const char* const sep = strchr(buff, ':');
1175*a28cd43dSSascha Wildner if (sep == NULL || *sep == '\0') {
1176*a28cd43dSSascha Wildner /* formatting was broken? */
1177*a28cd43dSSascha Wildner goto failed;
1178*a28cd43dSSascha Wildner }
1179*a28cd43dSSascha Wildner
1180*a28cd43dSSascha Wildner cpu_cores = atoi(sep + 1);
1181*a28cd43dSSascha Wildner }
1182*a28cd43dSSascha Wildner } else if (ferror(cpuinfo)) {
1183*a28cd43dSSascha Wildner /* fall back on the sysconf value */
1184*a28cd43dSSascha Wildner goto failed;
1185*a28cd43dSSascha Wildner } }
1186*a28cd43dSSascha Wildner if (siblings && cpu_cores) {
1187*a28cd43dSSascha Wildner ratio = siblings / cpu_cores;
1188*a28cd43dSSascha Wildner }
1189*a28cd43dSSascha Wildner failed:
1190*a28cd43dSSascha Wildner fclose(cpuinfo);
1191*a28cd43dSSascha Wildner return numPhysicalCores = numPhysicalCores / ratio;
1192*a28cd43dSSascha Wildner }
1193*a28cd43dSSascha Wildner }
1194*a28cd43dSSascha Wildner
1195*a28cd43dSSascha Wildner #elif defined(__FreeBSD__)
1196*a28cd43dSSascha Wildner
1197*a28cd43dSSascha Wildner #include <sys/param.h>
1198*a28cd43dSSascha Wildner #include <sys/sysctl.h>
1199*a28cd43dSSascha Wildner
1200*a28cd43dSSascha Wildner /* Use physical core sysctl when available
1201*a28cd43dSSascha Wildner * see: man 4 smp, man 3 sysctl */
UTIL_countPhysicalCores(void)1202*a28cd43dSSascha Wildner int UTIL_countPhysicalCores(void)
1203*a28cd43dSSascha Wildner {
1204*a28cd43dSSascha Wildner static int numPhysicalCores = 0; /* freebsd sysctl is native int sized */
1205*a28cd43dSSascha Wildner if (numPhysicalCores != 0) return numPhysicalCores;
1206*a28cd43dSSascha Wildner
1207*a28cd43dSSascha Wildner #if __FreeBSD_version >= 1300008
1208*a28cd43dSSascha Wildner { size_t size = sizeof(numPhysicalCores);
1209*a28cd43dSSascha Wildner int ret = sysctlbyname("kern.smp.cores", &numPhysicalCores, &size, NULL, 0);
1210*a28cd43dSSascha Wildner if (ret == 0) return numPhysicalCores;
1211*a28cd43dSSascha Wildner if (errno != ENOENT) {
1212*a28cd43dSSascha Wildner perror("zstd: can't get number of physical cpus");
1213*a28cd43dSSascha Wildner exit(1);
1214*a28cd43dSSascha Wildner }
1215*a28cd43dSSascha Wildner /* sysctl not present, fall through to older sysconf method */
1216*a28cd43dSSascha Wildner }
1217*a28cd43dSSascha Wildner #endif
1218*a28cd43dSSascha Wildner
1219*a28cd43dSSascha Wildner numPhysicalCores = (int)sysconf(_SC_NPROCESSORS_ONLN);
1220*a28cd43dSSascha Wildner if (numPhysicalCores == -1) {
1221*a28cd43dSSascha Wildner /* value not queryable, fall back on 1 */
1222*a28cd43dSSascha Wildner numPhysicalCores = 1;
1223*a28cd43dSSascha Wildner }
1224*a28cd43dSSascha Wildner return numPhysicalCores;
1225*a28cd43dSSascha Wildner }
1226*a28cd43dSSascha Wildner
1227*a28cd43dSSascha Wildner #elif defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__CYGWIN__)
1228*a28cd43dSSascha Wildner
1229*a28cd43dSSascha Wildner /* Use POSIX sysconf
1230*a28cd43dSSascha Wildner * see: man 3 sysconf */
UTIL_countPhysicalCores(void)1231*a28cd43dSSascha Wildner int UTIL_countPhysicalCores(void)
1232*a28cd43dSSascha Wildner {
1233*a28cd43dSSascha Wildner static int numPhysicalCores = 0;
1234*a28cd43dSSascha Wildner
1235*a28cd43dSSascha Wildner if (numPhysicalCores != 0) return numPhysicalCores;
1236*a28cd43dSSascha Wildner
1237*a28cd43dSSascha Wildner numPhysicalCores = (int)sysconf(_SC_NPROCESSORS_ONLN);
1238*a28cd43dSSascha Wildner if (numPhysicalCores == -1) {
1239*a28cd43dSSascha Wildner /* value not queryable, fall back on 1 */
1240*a28cd43dSSascha Wildner return numPhysicalCores = 1;
1241*a28cd43dSSascha Wildner }
1242*a28cd43dSSascha Wildner return numPhysicalCores;
1243*a28cd43dSSascha Wildner }
1244*a28cd43dSSascha Wildner
1245*a28cd43dSSascha Wildner #else
1246*a28cd43dSSascha Wildner
UTIL_countPhysicalCores(void)1247*a28cd43dSSascha Wildner int UTIL_countPhysicalCores(void)
1248*a28cd43dSSascha Wildner {
1249*a28cd43dSSascha Wildner /* assume 1 */
1250*a28cd43dSSascha Wildner return 1;
1251*a28cd43dSSascha Wildner }
1252*a28cd43dSSascha Wildner
1253*a28cd43dSSascha Wildner #endif
1254*a28cd43dSSascha Wildner
1255*a28cd43dSSascha Wildner #if defined (__cplusplus)
1256*a28cd43dSSascha Wildner }
1257*a28cd43dSSascha Wildner #endif
1258