notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
git subrepo pull (merge) --force deps/libchdr
[pcsx_rearmed.git] / deps / libchdr / deps / zstd-1.5.5 / programs / util.c
CommitLineData
648db22b 1/*
2 * Copyright (c) Meta Platforms, Inc. and affiliates.
3 * All rights reserved.
4 *
5 * This source code is licensed under both the BSD-style license (found in the
6 * LICENSE file in the root directory of this source tree) and the GPLv2 (found
7 * in the COPYING file in the root directory of this source tree).
8 * You may select, at your option, one of the above-listed licenses.
9 */
10
11#if defined (__cplusplus)
12extern "C" {
13#endif
14
15
16/*-****************************************
17* Dependencies
18******************************************/
19#include "util.h" /* note : ensure that platform.h is included first ! */
20#include <stdlib.h> /* malloc, realloc, free */
21#include <stdio.h> /* fprintf */
22#include <time.h> /* clock_t, clock, CLOCKS_PER_SEC, nanosleep */
23#include <errno.h>
24#include <assert.h>
25
26#if defined(_WIN32)
27# include <sys/utime.h> /* utime */
28# include <io.h> /* _chmod */
29#else
30# include <unistd.h> /* chown, stat */
31# if PLATFORM_POSIX_VERSION < 200809L || !defined(st_mtime)
32# include <utime.h> /* utime */
33# else
34# include <fcntl.h> /* AT_FDCWD */
35# include <sys/stat.h> /* utimensat */
36# endif
37#endif
38
39#if defined(_MSC_VER) || defined(__MINGW32__) || defined (__MSVCRT__)
40#include <direct.h> /* needed for _mkdir in windows */
41#endif
42
43#if defined(__linux__) || (PLATFORM_POSIX_VERSION >= 200112L) /* opendir, readdir require POSIX.1-2001 */
44# include <dirent.h> /* opendir, readdir */
45# include <string.h> /* strerror, memcpy */
46#endif /* #ifdef _WIN32 */
47
48/*-****************************************
49* Internal Macros
50******************************************/
51
52/* CONTROL is almost like an assert(), but is never disabled.
53 * It's designed for failures that may happen rarely,
54 * but we don't want to maintain a specific error code path for them,
55 * such as a malloc() returning NULL for example.
56 * Since it's always active, this macro can trigger side effects.
57 */
58#define CONTROL(c) { \
59 if (!(c)) { \
60 UTIL_DISPLAYLEVEL(1, "Error : %s, %i : %s", \
61 __FILE__, __LINE__, #c); \
62 exit(1); \
63} }
64
65/* console log */
66#define UTIL_DISPLAY(...) fprintf(stderr, __VA_ARGS__)
67#define UTIL_DISPLAYLEVEL(l, ...) { if (g_utilDisplayLevel>=l) { UTIL_DISPLAY(__VA_ARGS__); } }
68
69static int g_traceDepth = 0;
70int g_traceFileStat = 0;
71
72#define UTIL_TRACE_CALL(...) \
73 { \
74 if (g_traceFileStat) { \
75 UTIL_DISPLAY("Trace:FileStat: %*s> ", g_traceDepth, ""); \
76 UTIL_DISPLAY(__VA_ARGS__); \
77 UTIL_DISPLAY("\n"); \
78 ++g_traceDepth; \
79 } \
80 }
81
82#define UTIL_TRACE_RET(ret) \
83 { \
84 if (g_traceFileStat) { \
85 --g_traceDepth; \
86 UTIL_DISPLAY("Trace:FileStat: %*s< %d\n", g_traceDepth, "", (ret)); \
87 } \
88 }
89
90/* A modified version of realloc().
91 * If UTIL_realloc() fails the original block is freed.
92 */
93UTIL_STATIC void* UTIL_realloc(void *ptr, size_t size)
94{
95 void *newptr = realloc(ptr, size);
96 if (newptr) return newptr;
97 free(ptr);
98 return NULL;
99}
100
101#if defined(_MSC_VER)
102 #define chmod _chmod
103#endif
104
105#ifndef ZSTD_HAVE_FCHMOD
106#if PLATFORM_POSIX_VERSION >= 199309L
107#define ZSTD_HAVE_FCHMOD
108#endif
109#endif
110
111#ifndef ZSTD_HAVE_FCHOWN
112#if PLATFORM_POSIX_VERSION >= 200809L
113#define ZSTD_HAVE_FCHOWN
114#endif
115#endif
116
117/*-****************************************
118* Console log
119******************************************/
120int g_utilDisplayLevel;
121
122int UTIL_requireUserConfirmation(const char* prompt, const char* abortMsg,
123 const char* acceptableLetters, int hasStdinInput) {
124 int ch, result;
125
126 if (hasStdinInput) {
127 UTIL_DISPLAY("stdin is an input - not proceeding.\n");
128 return 1;
129 }
130
131 UTIL_DISPLAY("%s", prompt);
132 ch = getchar();
133 result = 0;
134 if (strchr(acceptableLetters, ch) == NULL) {
135 UTIL_DISPLAY("%s \n", abortMsg);
136 result = 1;
137 }
138 /* flush the rest */
139 while ((ch!=EOF) && (ch!='\n'))
140 ch = getchar();
141 return result;
142}
143
144
145/*-*************************************
146* Constants
147***************************************/
148#define LIST_SIZE_INCREASE (8*1024)
149#define MAX_FILE_OF_FILE_NAMES_SIZE (1<<20)*50
150
151
152/*-*************************************
153* Functions
154***************************************/
155
156void UTIL_traceFileStat(void)
157{
158 g_traceFileStat = 1;
159}
160
161int UTIL_fstat(const int fd, const char* filename, stat_t* statbuf)
162{
163 int ret;
164 UTIL_TRACE_CALL("UTIL_stat(%d, %s)", fd, filename);
165#if defined(_MSC_VER)
166 if (fd >= 0) {
167 ret = !_fstat64(fd, statbuf);
168 } else {
169 ret = !_stat64(filename, statbuf);
170 }
171#elif defined(__MINGW32__) && defined (__MSVCRT__)
172 if (fd >= 0) {
173 ret = !_fstati64(fd, statbuf);
174 } else {
175 ret = !_stati64(filename, statbuf);
176 }
177#else
178 if (fd >= 0) {
179 ret = !fstat(fd, statbuf);
180 } else {
181 ret = !stat(filename, statbuf);
182 }
183#endif
184 UTIL_TRACE_RET(ret);
185 return ret;
186}
187
188int UTIL_stat(const char* filename, stat_t* statbuf)
189{
190 return UTIL_fstat(-1, filename, statbuf);
191}
192
193int UTIL_isRegularFile(const char* infilename)
194{
195 stat_t statbuf;
196 int ret;
197 UTIL_TRACE_CALL("UTIL_isRegularFile(%s)", infilename);
198 ret = UTIL_stat(infilename, &statbuf) && UTIL_isRegularFileStat(&statbuf);
199 UTIL_TRACE_RET(ret);
200 return ret;
201}
202
203int UTIL_isRegularFileStat(const stat_t* statbuf)
204{
205#if defined(_MSC_VER)
206 return (statbuf->st_mode & S_IFREG) != 0;
207#else
208 return S_ISREG(statbuf->st_mode) != 0;
209#endif
210}
211
212/* like chmod, but avoid changing permission of /dev/null */
213int UTIL_chmod(char const* filename, const stat_t* statbuf, mode_t permissions)
214{
215 return UTIL_fchmod(-1, filename, statbuf, permissions);
216}
217
218int UTIL_fchmod(const int fd, char const* filename, const stat_t* statbuf, mode_t permissions)
219{
220 stat_t localStatBuf;
221 UTIL_TRACE_CALL("UTIL_chmod(%s, %#4o)", filename, (unsigned)permissions);
222 if (statbuf == NULL) {
223 if (!UTIL_fstat(fd, filename, &localStatBuf)) {
224 UTIL_TRACE_RET(0);
225 return 0;
226 }
227 statbuf = &localStatBuf;
228 }
229 if (!UTIL_isRegularFileStat(statbuf)) {
230 UTIL_TRACE_RET(0);
231 return 0; /* pretend success, but don't change anything */
232 }
233#ifdef ZSTD_HAVE_FCHMOD
234 if (fd >= 0) {
235 int ret;
236 UTIL_TRACE_CALL("fchmod");
237 ret = fchmod(fd, permissions);
238 UTIL_TRACE_RET(ret);
239 UTIL_TRACE_RET(ret);
240 return ret;
241 } else
242#endif
243 {
244 int ret;
245 UTIL_TRACE_CALL("chmod");
246 ret = chmod(filename, permissions);
247 UTIL_TRACE_RET(ret);
248 UTIL_TRACE_RET(ret);
249 return ret;
250 }
251}
252
253/* set access and modification times */
254int UTIL_utime(const char* filename, const stat_t *statbuf)
255{
256 int ret;
257 UTIL_TRACE_CALL("UTIL_utime(%s)", filename);
258 /* We check that st_mtime is a macro here in order to give us confidence
259 * that struct stat has a struct timespec st_mtim member. We need this
260 * check because there are some platforms that claim to be POSIX 2008
261 * compliant but which do not have st_mtim... */
262#if (PLATFORM_POSIX_VERSION >= 200809L) && defined(st_mtime)
263 {
264 /* (atime, mtime) */
265 struct timespec timebuf[2] = { {0, UTIME_NOW} };
266 timebuf[1] = statbuf->st_mtim;
267 ret = utimensat(AT_FDCWD, filename, timebuf, 0);
268 }
269#else
270 {
271 struct utimbuf timebuf;
272 timebuf.actime = time(NULL);
273 timebuf.modtime = statbuf->st_mtime;
274 ret = utime(filename, &timebuf);
275 }
276#endif
277 errno = 0;
278 UTIL_TRACE_RET(ret);
279 return ret;
280}
281
282int UTIL_setFileStat(const char *filename, const stat_t *statbuf)
283{
284 return UTIL_setFDStat(-1, filename, statbuf);
285}
286
287int UTIL_setFDStat(const int fd, const char *filename, const stat_t *statbuf)
288{
289 int res = 0;
290 stat_t curStatBuf;
291 UTIL_TRACE_CALL("UTIL_setFileStat(%d, %s)", fd, filename);
292
293 if (!UTIL_fstat(fd, filename, &curStatBuf) || !UTIL_isRegularFileStat(&curStatBuf)) {
294 UTIL_TRACE_RET(-1);
295 return -1;
296 }
297
298 /* Mimic gzip's behavior:
299 *
300 * "Change the group first, then the permissions, then the owner.
301 * That way, the permissions will be correct on systems that allow
302 * users to give away files, without introducing a security hole.
303 * Security depends on permissions not containing the setuid or
304 * setgid bits." */
305
306#if !defined(_WIN32)
307#ifdef ZSTD_HAVE_FCHOWN
308 if (fd >= 0) {
309 res += fchown(fd, -1, statbuf->st_gid); /* Apply group ownership */
310 } else
311#endif
312 {
313 res += chown(filename, -1, statbuf->st_gid); /* Apply group ownership */
314 }
315#endif
316
317 res += UTIL_fchmod(fd, filename, &curStatBuf, statbuf->st_mode & 0777); /* Copy file permissions */
318
319#if !defined(_WIN32)
320#ifdef ZSTD_HAVE_FCHOWN
321 if (fd >= 0) {
322 res += fchown(fd, statbuf->st_uid, -1); /* Apply user ownership */
323 } else
324#endif
325 {
326 res += chown(filename, statbuf->st_uid, -1); /* Apply user ownership */
327 }
328#endif
329
330 errno = 0;
331 UTIL_TRACE_RET(-res);
332 return -res; /* number of errors is returned */
333}
334
335int UTIL_isDirectory(const char* infilename)
336{
337 stat_t statbuf;
338 int ret;
339 UTIL_TRACE_CALL("UTIL_isDirectory(%s)", infilename);
340 ret = UTIL_stat(infilename, &statbuf) && UTIL_isDirectoryStat(&statbuf);
341 UTIL_TRACE_RET(ret);
342 return ret;
343}
344
345int UTIL_isDirectoryStat(const stat_t* statbuf)
346{
347 int ret;
348 UTIL_TRACE_CALL("UTIL_isDirectoryStat()");
349#if defined(_MSC_VER)
350 ret = (statbuf->st_mode & _S_IFDIR) != 0;
351#else
352 ret = S_ISDIR(statbuf->st_mode) != 0;
353#endif
354 UTIL_TRACE_RET(ret);
355 return ret;
356}
357
358int UTIL_compareStr(const void *p1, const void *p2) {
359 return strcmp(* (char * const *) p1, * (char * const *) p2);
360}
361
362int UTIL_isSameFile(const char* fName1, const char* fName2)
363{
364 int ret;
365 assert(fName1 != NULL); assert(fName2 != NULL);
366 UTIL_TRACE_CALL("UTIL_isSameFile(%s, %s)", fName1, fName2);
367#if defined(_MSC_VER) || defined(_WIN32)
368 /* note : Visual does not support file identification by inode.
369 * inode does not work on Windows, even with a posix layer, like msys2.
370 * The following work-around is limited to detecting exact name repetition only,
371 * aka `filename` is considered different from `subdir/../filename` */
372 ret = !strcmp(fName1, fName2);
373#else
374 { stat_t file1Stat;
375 stat_t file2Stat;
376 ret = UTIL_stat(fName1, &file1Stat)
377 && UTIL_stat(fName2, &file2Stat)
378 && UTIL_isSameFileStat(fName1, fName2, &file1Stat, &file2Stat);
379 }
380#endif
381 UTIL_TRACE_RET(ret);
382 return ret;
383}
384
385int UTIL_isSameFileStat(
386 const char* fName1, const char* fName2,
387 const stat_t* file1Stat, const stat_t* file2Stat)
388{
389 int ret;
390 assert(fName1 != NULL); assert(fName2 != NULL);
391 UTIL_TRACE_CALL("UTIL_isSameFileStat(%s, %s)", fName1, fName2);
392#if defined(_MSC_VER) || defined(_WIN32)
393 /* note : Visual does not support file identification by inode.
394 * inode does not work on Windows, even with a posix layer, like msys2.
395 * The following work-around is limited to detecting exact name repetition only,
396 * aka `filename` is considered different from `subdir/../filename` */
397 (void)file1Stat;
398 (void)file2Stat;
399 ret = !strcmp(fName1, fName2);
400#else
401 {
402 ret = (file1Stat->st_dev == file2Stat->st_dev)
403 && (file1Stat->st_ino == file2Stat->st_ino);
404 }
405#endif
406 UTIL_TRACE_RET(ret);
407 return ret;
408}
409
410/* UTIL_isFIFO : distinguish named pipes */
411int UTIL_isFIFO(const char* infilename)
412{
413 UTIL_TRACE_CALL("UTIL_isFIFO(%s)", infilename);
414/* macro guards, as defined in : https://linux.die.net/man/2/lstat */
415#if PLATFORM_POSIX_VERSION >= 200112L
416 {
417 stat_t statbuf;
418 if (UTIL_stat(infilename, &statbuf) && UTIL_isFIFOStat(&statbuf)) {
419 UTIL_TRACE_RET(1);
420 return 1;
421 }
422 }
423#endif
424 (void)infilename;
425 UTIL_TRACE_RET(0);
426 return 0;
427}
428
429/* UTIL_isFIFO : distinguish named pipes */
430int UTIL_isFIFOStat(const stat_t* statbuf)
431{
432/* macro guards, as defined in : https://linux.die.net/man/2/lstat */
433#if PLATFORM_POSIX_VERSION >= 200112L
434 if (S_ISFIFO(statbuf->st_mode)) return 1;
435#endif
436 (void)statbuf;
437 return 0;
438}
439
440/* UTIL_isBlockDevStat : distinguish named pipes */
441int UTIL_isBlockDevStat(const stat_t* statbuf)
442{
443/* macro guards, as defined in : https://linux.die.net/man/2/lstat */
444#if PLATFORM_POSIX_VERSION >= 200112L
445 if (S_ISBLK(statbuf->st_mode)) return 1;
446#endif
447 (void)statbuf;
448 return 0;
449}
450
451int UTIL_isLink(const char* infilename)
452{
453 UTIL_TRACE_CALL("UTIL_isLink(%s)", infilename);
454/* macro guards, as defined in : https://linux.die.net/man/2/lstat */
455#if PLATFORM_POSIX_VERSION >= 200112L
456 {
457 stat_t statbuf;
458 int const r = lstat(infilename, &statbuf);
459 if (!r && S_ISLNK(statbuf.st_mode)) {
460 UTIL_TRACE_RET(1);
461 return 1;
462 }
463 }
464#endif
465 (void)infilename;
466 UTIL_TRACE_RET(0);
467 return 0;
468}
469
470static int g_fakeStdinIsConsole = 0;
471static int g_fakeStderrIsConsole = 0;
472static int g_fakeStdoutIsConsole = 0;
473
474int UTIL_isConsole(FILE* file)
475{
476 int ret;
477 UTIL_TRACE_CALL("UTIL_isConsole(%d)", fileno(file));
478 if (file == stdin && g_fakeStdinIsConsole)
479 ret = 1;
480 else if (file == stderr && g_fakeStderrIsConsole)
481 ret = 1;
482 else if (file == stdout && g_fakeStdoutIsConsole)
483 ret = 1;
484 else
485 ret = IS_CONSOLE(file);
486 UTIL_TRACE_RET(ret);
487 return ret;
488}
489
490void UTIL_fakeStdinIsConsole(void)
491{
492 g_fakeStdinIsConsole = 1;
493}
494void UTIL_fakeStdoutIsConsole(void)
495{
496 g_fakeStdoutIsConsole = 1;
497}
498void UTIL_fakeStderrIsConsole(void)
499{
500 g_fakeStderrIsConsole = 1;
501}
502
503U64 UTIL_getFileSize(const char* infilename)
504{
505 stat_t statbuf;
506 UTIL_TRACE_CALL("UTIL_getFileSize(%s)", infilename);
507 if (!UTIL_stat(infilename, &statbuf)) {
508 UTIL_TRACE_RET(-1);
509 return UTIL_FILESIZE_UNKNOWN;
510 }
511 {
512 U64 const size = UTIL_getFileSizeStat(&statbuf);
513 UTIL_TRACE_RET((int)size);
514 return size;
515 }
516}
517
518U64 UTIL_getFileSizeStat(const stat_t* statbuf)
519{
520 if (!UTIL_isRegularFileStat(statbuf)) return UTIL_FILESIZE_UNKNOWN;
521#if defined(_MSC_VER)
522 if (!(statbuf->st_mode & S_IFREG)) return UTIL_FILESIZE_UNKNOWN;
523#elif defined(__MINGW32__) && defined (__MSVCRT__)
524 if (!(statbuf->st_mode & S_IFREG)) return UTIL_FILESIZE_UNKNOWN;
525#else
526 if (!S_ISREG(statbuf->st_mode)) return UTIL_FILESIZE_UNKNOWN;
527#endif
528 return (U64)statbuf->st_size;
529}
530
531UTIL_HumanReadableSize_t UTIL_makeHumanReadableSize(U64 size)
532{
533 UTIL_HumanReadableSize_t hrs;
534
535 if (g_utilDisplayLevel > 3) {
536 /* In verbose mode, do not scale sizes down, except in the case of
537 * values that exceed the integral precision of a double. */
538 if (size >= (1ull << 53)) {
539 hrs.value = (double)size / (1ull << 20);
540 hrs.suffix = " MiB";
541 /* At worst, a double representation of a maximal size will be
542 * accurate to better than tens of kilobytes. */
543 hrs.precision = 2;
544 } else {
545 hrs.value = (double)size;
546 hrs.suffix = " B";
547 hrs.precision = 0;
548 }
549 } else {
550 /* In regular mode, scale sizes down and use suffixes. */
551 if (size >= (1ull << 60)) {
552 hrs.value = (double)size / (1ull << 60);
553 hrs.suffix = " EiB";
554 } else if (size >= (1ull << 50)) {
555 hrs.value = (double)size / (1ull << 50);
556 hrs.suffix = " PiB";
557 } else if (size >= (1ull << 40)) {
558 hrs.value = (double)size / (1ull << 40);
559 hrs.suffix = " TiB";
560 } else if (size >= (1ull << 30)) {
561 hrs.value = (double)size / (1ull << 30);
562 hrs.suffix = " GiB";
563 } else if (size >= (1ull << 20)) {
564 hrs.value = (double)size / (1ull << 20);
565 hrs.suffix = " MiB";
566 } else if (size >= (1ull << 10)) {
567 hrs.value = (double)size / (1ull << 10);
568 hrs.suffix = " KiB";
569 } else {
570 hrs.value = (double)size;
571 hrs.suffix = " B";
572 }
573
574 if (hrs.value >= 100 || (U64)hrs.value == size) {
575 hrs.precision = 0;
576 } else if (hrs.value >= 10) {
577 hrs.precision = 1;
578 } else if (hrs.value > 1) {
579 hrs.precision = 2;
580 } else {
581 hrs.precision = 3;
582 }
583 }
584
585 return hrs;
586}
587
588U64 UTIL_getTotalFileSize(const char* const * fileNamesTable, unsigned nbFiles)
589{
590 U64 total = 0;
591 unsigned n;
592 UTIL_TRACE_CALL("UTIL_getTotalFileSize(%u)", nbFiles);
593 for (n=0; n<nbFiles; n++) {
594 U64 const size = UTIL_getFileSize(fileNamesTable[n]);
595 if (size == UTIL_FILESIZE_UNKNOWN) {
596 UTIL_TRACE_RET(-1);
597 return UTIL_FILESIZE_UNKNOWN;
598 }
599 total += size;
600 }
601 UTIL_TRACE_RET((int)total);
602 return total;
603}
604
605
606/* condition : @file must be valid, and not have reached its end.
607 * @return : length of line written into @buf, ended with `\0` instead of '\n',
608 * or 0, if there is no new line */
609static size_t readLineFromFile(char* buf, size_t len, FILE* file)
610{
611 assert(!feof(file));
612 if ( fgets(buf, (int) len, file) == NULL ) return 0;
613 { size_t linelen = strlen(buf);
614 if (strlen(buf)==0) return 0;
615 if (buf[linelen-1] == '\n') linelen--;
616 buf[linelen] = '\0';
617 return linelen+1;
618 }
619}
620
621/* Conditions :
622 * size of @inputFileName file must be < @dstCapacity
623 * @dst must be initialized
624 * @return : nb of lines
625 * or -1 if there's an error
626 */
627static int
628readLinesFromFile(void* dst, size_t dstCapacity,
629 const char* inputFileName)
630{
631 int nbFiles = 0;
632 size_t pos = 0;
633 char* const buf = (char*)dst;
634 FILE* const inputFile = fopen(inputFileName, "r");
635
636 assert(dst != NULL);
637
638 if(!inputFile) {
639 if (g_utilDisplayLevel >= 1) perror("zstd:util:readLinesFromFile");
640 return -1;
641 }
642
643 while ( !feof(inputFile) ) {
644 size_t const lineLength = readLineFromFile(buf+pos, dstCapacity-pos, inputFile);
645 if (lineLength == 0) break;
646 assert(pos + lineLength <= dstCapacity); /* '=' for inputFile not terminated with '\n' */
647 pos += lineLength;
648 ++nbFiles;
649 }
650
651 CONTROL( fclose(inputFile) == 0 );
652
653 return nbFiles;
654}
655
656/*Note: buf is not freed in case function successfully created table because filesTable->fileNames[0] = buf*/
657FileNamesTable*
658UTIL_createFileNamesTable_fromFileName(const char* inputFileName)
659{
660 size_t nbFiles = 0;
661 char* buf;
662 size_t bufSize;
663 size_t pos = 0;
664 stat_t statbuf;
665
666 if (!UTIL_stat(inputFileName, &statbuf) || !UTIL_isRegularFileStat(&statbuf))
667 return NULL;
668
669 { U64 const inputFileSize = UTIL_getFileSizeStat(&statbuf);
670 if(inputFileSize > MAX_FILE_OF_FILE_NAMES_SIZE)
671 return NULL;
672 bufSize = (size_t)(inputFileSize + 1); /* (+1) to add '\0' at the end of last filename */
673 }
674
675 buf = (char*) malloc(bufSize);
676 CONTROL( buf != NULL );
677
678 { int const ret_nbFiles = readLinesFromFile(buf, bufSize, inputFileName);
679
680 if (ret_nbFiles <= 0) {
681 free(buf);
682 return NULL;
683 }
684 nbFiles = (size_t)ret_nbFiles;
685 }
686
687 { const char** filenamesTable = (const char**) malloc(nbFiles * sizeof(*filenamesTable));
688 CONTROL(filenamesTable != NULL);
689
690 { size_t fnb;
691 for (fnb = 0, pos = 0; fnb < nbFiles; fnb++) {
692 filenamesTable[fnb] = buf+pos;
693 pos += strlen(buf+pos)+1; /* +1 for the finishing `\0` */
694 } }
695 assert(pos <= bufSize);
696
697 return UTIL_assembleFileNamesTable(filenamesTable, nbFiles, buf);
698 }
699}
700
701static FileNamesTable*
702UTIL_assembleFileNamesTable2(const char** filenames, size_t tableSize, size_t tableCapacity, char* buf)
703{
704 FileNamesTable* const table = (FileNamesTable*) malloc(sizeof(*table));
705 CONTROL(table != NULL);
706 table->fileNames = filenames;
707 table->buf = buf;
708 table->tableSize = tableSize;
709 table->tableCapacity = tableCapacity;
710 return table;
711}
712
713FileNamesTable*
714UTIL_assembleFileNamesTable(const char** filenames, size_t tableSize, char* buf)
715{
716 return UTIL_assembleFileNamesTable2(filenames, tableSize, tableSize, buf);
717}
718
719void UTIL_freeFileNamesTable(FileNamesTable* table)
720{
721 if (table==NULL) return;
722 free((void*)table->fileNames);
723 free(table->buf);
724 free(table);
725}
726
727FileNamesTable* UTIL_allocateFileNamesTable(size_t tableSize)
728{
729 const char** const fnTable = (const char**)malloc(tableSize * sizeof(*fnTable));
730 FileNamesTable* fnt;
731 if (fnTable==NULL) return NULL;
732 fnt = UTIL_assembleFileNamesTable(fnTable, tableSize, NULL);
733 fnt->tableSize = 0; /* the table is empty */
734 return fnt;
735}
736
737int UTIL_searchFileNamesTable(FileNamesTable* table, char const* name) {
738 size_t i;
739 for(i=0 ;i < table->tableSize; i++) {
740 if(!strcmp(table->fileNames[i], name)) {
741 return (int)i;
742 }
743 }
744 return -1;
745}
746
747void UTIL_refFilename(FileNamesTable* fnt, const char* filename)
748{
749 assert(fnt->tableSize < fnt->tableCapacity);
750 fnt->fileNames[fnt->tableSize] = filename;
751 fnt->tableSize++;
752}
753
754static size_t getTotalTableSize(FileNamesTable* table)
755{
756 size_t fnb = 0, totalSize = 0;
757 for(fnb = 0 ; fnb < table->tableSize && table->fileNames[fnb] ; ++fnb) {
758 totalSize += strlen(table->fileNames[fnb]) + 1; /* +1 to add '\0' at the end of each fileName */
759 }
760 return totalSize;
761}
762
763FileNamesTable*
764UTIL_mergeFileNamesTable(FileNamesTable* table1, FileNamesTable* table2)
765{
766 unsigned newTableIdx = 0;
767 size_t pos = 0;
768 size_t newTotalTableSize;
769 char* buf;
770
771 FileNamesTable* const newTable = UTIL_assembleFileNamesTable(NULL, 0, NULL);
772 CONTROL( newTable != NULL );
773
774 newTotalTableSize = getTotalTableSize(table1) + getTotalTableSize(table2);
775
776 buf = (char*) calloc(newTotalTableSize, sizeof(*buf));
777 CONTROL ( buf != NULL );
778
779 newTable->buf = buf;
780 newTable->tableSize = table1->tableSize + table2->tableSize;
781 newTable->fileNames = (const char **) calloc(newTable->tableSize, sizeof(*(newTable->fileNames)));
782 CONTROL ( newTable->fileNames != NULL );
783
784 { unsigned idx1;
785 for( idx1=0 ; (idx1 < table1->tableSize) && table1->fileNames[idx1] && (pos < newTotalTableSize); ++idx1, ++newTableIdx) {
786 size_t const curLen = strlen(table1->fileNames[idx1]);
787 memcpy(buf+pos, table1->fileNames[idx1], curLen);
788 assert(newTableIdx <= newTable->tableSize);
789 newTable->fileNames[newTableIdx] = buf+pos;
790 pos += curLen+1;
791 } }
792
793 { unsigned idx2;
794 for( idx2=0 ; (idx2 < table2->tableSize) && table2->fileNames[idx2] && (pos < newTotalTableSize) ; ++idx2, ++newTableIdx) {
795 size_t const curLen = strlen(table2->fileNames[idx2]);
796 memcpy(buf+pos, table2->fileNames[idx2], curLen);
797 assert(newTableIdx < newTable->tableSize);
798 newTable->fileNames[newTableIdx] = buf+pos;
799 pos += curLen+1;
800 } }
801 assert(pos <= newTotalTableSize);
802 newTable->tableSize = newTableIdx;
803
804 UTIL_freeFileNamesTable(table1);
805 UTIL_freeFileNamesTable(table2);
806
807 return newTable;
808}
809
810#ifdef _WIN32
811static int UTIL_prepareFileList(const char* dirName,
812 char** bufStart, size_t* pos,
813 char** bufEnd, int followLinks)
814{
815 char* path;
816 size_t dirLength, pathLength;
817 int nbFiles = 0;
818 WIN32_FIND_DATAA cFile;
819 HANDLE hFile;
820
821 dirLength = strlen(dirName);
822 path = (char*) malloc(dirLength + 3);
823 if (!path) return 0;
824
825 memcpy(path, dirName, dirLength);
826 path[dirLength] = '\\';
827 path[dirLength+1] = '*';
828 path[dirLength+2] = 0;
829
830 hFile=FindFirstFileA(path, &cFile);
831 if (hFile == INVALID_HANDLE_VALUE) {
832 UTIL_DISPLAYLEVEL(1, "Cannot open directory '%s'\n", dirName);
833 return 0;
834 }
835 free(path);
836
837 do {
838 size_t const fnameLength = strlen(cFile.cFileName);
839 path = (char*) malloc(dirLength + fnameLength + 2);
840 if (!path) { FindClose(hFile); return 0; }
841 memcpy(path, dirName, dirLength);
842 path[dirLength] = '\\';
843 memcpy(path+dirLength+1, cFile.cFileName, fnameLength);
844 pathLength = dirLength+1+fnameLength;
845 path[pathLength] = 0;
846 if (cFile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
847 if ( strcmp (cFile.cFileName, "..") == 0
848 || strcmp (cFile.cFileName, ".") == 0 )
849 continue;
850 /* Recursively call "UTIL_prepareFileList" with the new path. */
851 nbFiles += UTIL_prepareFileList(path, bufStart, pos, bufEnd, followLinks);
852 if (*bufStart == NULL) { free(path); FindClose(hFile); return 0; }
853 } else if ( (cFile.dwFileAttributes & FILE_ATTRIBUTE_NORMAL)
854 || (cFile.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE)
855 || (cFile.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED) ) {
856 if (*bufStart + *pos + pathLength >= *bufEnd) {
857 ptrdiff_t const newListSize = (*bufEnd - *bufStart) + LIST_SIZE_INCREASE;
858 *bufStart = (char*)UTIL_realloc(*bufStart, newListSize);
859 if (*bufStart == NULL) { free(path); FindClose(hFile); return 0; }
860 *bufEnd = *bufStart + newListSize;
861 }
862 if (*bufStart + *pos + pathLength < *bufEnd) {
863 memcpy(*bufStart + *pos, path, pathLength+1 /* include final \0 */);
864 *pos += pathLength + 1;
865 nbFiles++;
866 } }
867 free(path);
868 } while (FindNextFileA(hFile, &cFile));
869
870 FindClose(hFile);
871 return nbFiles;
872}
873
874#elif defined(__linux__) || (PLATFORM_POSIX_VERSION >= 200112L) /* opendir, readdir require POSIX.1-2001 */
875
876static int UTIL_prepareFileList(const char *dirName,
877 char** bufStart, size_t* pos,
878 char** bufEnd, int followLinks)
879{
880 DIR* dir;
881 struct dirent * entry;
882 size_t dirLength;
883 int nbFiles = 0;
884
885 if (!(dir = opendir(dirName))) {
886 UTIL_DISPLAYLEVEL(1, "Cannot open directory '%s': %s\n", dirName, strerror(errno));
887 return 0;
888 }
889
890 dirLength = strlen(dirName);
891 errno = 0;
892 while ((entry = readdir(dir)) != NULL) {
893 char* path;
894 size_t fnameLength, pathLength;
895 if (strcmp (entry->d_name, "..") == 0 ||
896 strcmp (entry->d_name, ".") == 0) continue;
897 fnameLength = strlen(entry->d_name);
898 path = (char*) malloc(dirLength + fnameLength + 2);
899 if (!path) { closedir(dir); return 0; }
900 memcpy(path, dirName, dirLength);
901
902 path[dirLength] = '/';
903 memcpy(path+dirLength+1, entry->d_name, fnameLength);
904 pathLength = dirLength+1+fnameLength;
905 path[pathLength] = 0;
906
907 if (!followLinks && UTIL_isLink(path)) {
908 UTIL_DISPLAYLEVEL(2, "Warning : %s is a symbolic link, ignoring\n", path);
909 free(path);
910 continue;
911 }
912
913 if (UTIL_isDirectory(path)) {
914 nbFiles += UTIL_prepareFileList(path, bufStart, pos, bufEnd, followLinks); /* Recursively call "UTIL_prepareFileList" with the new path. */
915 if (*bufStart == NULL) { free(path); closedir(dir); return 0; }
916 } else {
917 if (*bufStart + *pos + pathLength >= *bufEnd) {
918 ptrdiff_t newListSize = (*bufEnd - *bufStart) + LIST_SIZE_INCREASE;
919 assert(newListSize >= 0);
920 *bufStart = (char*)UTIL_realloc(*bufStart, (size_t)newListSize);
921 if (*bufStart != NULL) {
922 *bufEnd = *bufStart + newListSize;
923 } else {
924 free(path); closedir(dir); return 0;
925 }
926 }
927 if (*bufStart + *pos + pathLength < *bufEnd) {
928 memcpy(*bufStart + *pos, path, pathLength + 1); /* with final \0 */
929 *pos += pathLength + 1;
930 nbFiles++;
931 } }
932 free(path);
933 errno = 0; /* clear errno after UTIL_isDirectory, UTIL_prepareFileList */
934 }
935
936 if (errno != 0) {
937 UTIL_DISPLAYLEVEL(1, "readdir(%s) error: %s \n", dirName, strerror(errno));
938 free(*bufStart);
939 *bufStart = NULL;
940 }
941 closedir(dir);
942 return nbFiles;
943}
944
945#else
946
947static int UTIL_prepareFileList(const char *dirName,
948 char** bufStart, size_t* pos,
949 char** bufEnd, int followLinks)
950{
951 (void)bufStart; (void)bufEnd; (void)pos; (void)followLinks;
952 UTIL_DISPLAYLEVEL(1, "Directory %s ignored (compiled without _WIN32 or _POSIX_C_SOURCE) \n", dirName);
953 return 0;
954}
955
956#endif /* #ifdef _WIN32 */
957
958int UTIL_isCompressedFile(const char *inputName, const char *extensionList[])
959{
960 const char* ext = UTIL_getFileExtension(inputName);
961 while(*extensionList!=NULL)
962 {
963 const int isCompressedExtension = strcmp(ext,*extensionList);
964 if(isCompressedExtension==0)
965 return 1;
966 ++extensionList;
967 }
968 return 0;
969}
970
971/*Utility function to get file extension from file */
972const char* UTIL_getFileExtension(const char* infilename)
973{
974 const char* extension = strrchr(infilename, '.');
975 if(!extension || extension==infilename) return "";
976 return extension;
977}
978
979static int pathnameHas2Dots(const char *pathname)
980{
981 /* We need to figure out whether any ".." present in the path is a whole
982 * path token, which is the case if it is bordered on both sides by either
983 * the beginning/end of the path or by a directory separator.
984 */
985 const char *needle = pathname;
986 while (1) {
987 needle = strstr(needle, "..");
988
989 if (needle == NULL) {
990 return 0;
991 }
992
993 if ((needle == pathname || needle[-1] == PATH_SEP)
994 && (needle[2] == '\0' || needle[2] == PATH_SEP)) {
995 return 1;
996 }
997
998 /* increment so we search for the next match */
999 needle++;
1000 };
1001 return 0;
1002}
1003
1004static int isFileNameValidForMirroredOutput(const char *filename)
1005{
1006 return !pathnameHas2Dots(filename);
1007}
1008
1009
1010#define DIR_DEFAULT_MODE 0755
1011static mode_t getDirMode(const char *dirName)
1012{
1013 stat_t st;
1014 if (!UTIL_stat(dirName, &st)) {
1015 UTIL_DISPLAY("zstd: failed to get DIR stats %s: %s\n", dirName, strerror(errno));
1016 return DIR_DEFAULT_MODE;
1017 }
1018 if (!UTIL_isDirectoryStat(&st)) {
1019 UTIL_DISPLAY("zstd: expected directory: %s\n", dirName);
1020 return DIR_DEFAULT_MODE;
1021 }
1022 return st.st_mode;
1023}
1024
1025static int makeDir(const char *dir, mode_t mode)
1026{
1027#if defined(_MSC_VER) || defined(__MINGW32__) || defined (__MSVCRT__)
1028 int ret = _mkdir(dir);
1029 (void) mode;
1030#else
1031 int ret = mkdir(dir, mode);
1032#endif
1033 if (ret != 0) {
1034 if (errno == EEXIST)
1035 return 0;
1036 UTIL_DISPLAY("zstd: failed to create DIR %s: %s\n", dir, strerror(errno));
1037 }
1038 return ret;
1039}
1040
1041/* this function requires a mutable input string */
1042static void convertPathnameToDirName(char *pathname)
1043{
1044 size_t len = 0;
1045 char* pos = NULL;
1046 /* get dir name from pathname similar to 'dirname()' */
1047 assert(pathname != NULL);
1048
1049 /* remove trailing '/' chars */
1050 len = strlen(pathname);
1051 assert(len > 0);
1052 while (pathname[len] == PATH_SEP) {
1053 pathname[len] = '\0';
1054 len--;
1055 }
1056 if (len == 0) return;
1057
1058 /* if input is a single file, return '.' instead. i.e.
1059 * "xyz/abc/file.txt" => "xyz/abc"
1060 "./file.txt" => "."
1061 "file.txt" => "."
1062 */
1063 pos = strrchr(pathname, PATH_SEP);
1064 if (pos == NULL) {
1065 pathname[0] = '.';
1066 pathname[1] = '\0';
1067 } else {
1068 *pos = '\0';
1069 }
1070}
1071
1072/* pathname must be valid */
1073static const char* trimLeadingRootChar(const char *pathname)
1074{
1075 assert(pathname != NULL);
1076 if (pathname[0] == PATH_SEP)
1077 return pathname + 1;
1078 return pathname;
1079}
1080
1081/* pathname must be valid */
1082static const char* trimLeadingCurrentDirConst(const char *pathname)
1083{
1084 assert(pathname != NULL);
1085 if ((pathname[0] == '.') && (pathname[1] == PATH_SEP))
1086 return pathname + 2;
1087 return pathname;
1088}
1089
1090static char*
1091trimLeadingCurrentDir(char *pathname)
1092{
1093 /* 'union charunion' can do const-cast without compiler warning */
1094 union charunion {
1095 char *chr;
1096 const char* cchr;
1097 } ptr;
1098 ptr.cchr = trimLeadingCurrentDirConst(pathname);
1099 return ptr.chr;
1100}
1101
1102/* remove leading './' or '/' chars here */
1103static const char * trimPath(const char *pathname)
1104{
1105 return trimLeadingRootChar(
1106 trimLeadingCurrentDirConst(pathname));
1107}
1108
1109static char* mallocAndJoin2Dir(const char *dir1, const char *dir2)
1110{
1111 assert(dir1 != NULL && dir2 != NULL);
1112 { const size_t dir1Size = strlen(dir1);
1113 const size_t dir2Size = strlen(dir2);
1114 char *outDirBuffer, *buffer;
1115
1116 outDirBuffer = (char *) malloc(dir1Size + dir2Size + 2);
1117 CONTROL(outDirBuffer != NULL);
1118
1119 memcpy(outDirBuffer, dir1, dir1Size);
1120 outDirBuffer[dir1Size] = '\0';
1121
1122 if (dir2[0] == '.')
1123 return outDirBuffer;
1124
1125 buffer = outDirBuffer + dir1Size;
1126 if (dir1Size > 0 && *(buffer - 1) != PATH_SEP) {
1127 *buffer = PATH_SEP;
1128 buffer++;
1129 }
1130 memcpy(buffer, dir2, dir2Size);
1131 buffer[dir2Size] = '\0';
1132
1133 return outDirBuffer;
1134 }
1135}
1136
1137/* this function will return NULL if input srcFileName is not valid name for mirrored output path */
1138char* UTIL_createMirroredDestDirName(const char* srcFileName, const char* outDirRootName)
1139{
1140 char* pathname = NULL;
1141 if (!isFileNameValidForMirroredOutput(srcFileName))
1142 return NULL;
1143
1144 pathname = mallocAndJoin2Dir(outDirRootName, trimPath(srcFileName));
1145
1146 convertPathnameToDirName(pathname);
1147 return pathname;
1148}
1149
1150static int
1151mirrorSrcDir(char* srcDirName, const char* outDirName)
1152{
1153 mode_t srcMode;
1154 int status = 0;
1155 char* newDir = mallocAndJoin2Dir(outDirName, trimPath(srcDirName));
1156 if (!newDir)
1157 return -ENOMEM;
1158
1159 srcMode = getDirMode(srcDirName);
1160 status = makeDir(newDir, srcMode);
1161 free(newDir);
1162 return status;
1163}
1164
1165static int
1166mirrorSrcDirRecursive(char* srcDirName, const char* outDirName)
1167{
1168 int status = 0;
1169 char* pp = trimLeadingCurrentDir(srcDirName);
1170 char* sp = NULL;
1171
1172 while ((sp = strchr(pp, PATH_SEP)) != NULL) {
1173 if (sp != pp) {
1174 *sp = '\0';
1175 status = mirrorSrcDir(srcDirName, outDirName);
1176 if (status != 0)
1177 return status;
1178 *sp = PATH_SEP;
1179 }
1180 pp = sp + 1;
1181 }
1182 status = mirrorSrcDir(srcDirName, outDirName);
1183 return status;
1184}
1185
1186static void
1187makeMirroredDestDirsWithSameSrcDirMode(char** srcDirNames, unsigned nbFile, const char* outDirName)
1188{
1189 unsigned int i = 0;
1190 for (i = 0; i < nbFile; i++)
1191 mirrorSrcDirRecursive(srcDirNames[i], outDirName);
1192}
1193
1194static int
1195firstIsParentOrSameDirOfSecond(const char* firstDir, const char* secondDir)
1196{
1197 size_t firstDirLen = strlen(firstDir),
1198 secondDirLen = strlen(secondDir);
1199 return firstDirLen <= secondDirLen &&
1200 (secondDir[firstDirLen] == PATH_SEP || secondDir[firstDirLen] == '\0') &&
1201 0 == strncmp(firstDir, secondDir, firstDirLen);
1202}
1203
1204static int compareDir(const void* pathname1, const void* pathname2) {
1205 /* sort it after remove the leading '/' or './'*/
1206 const char* s1 = trimPath(*(char * const *) pathname1);
1207 const char* s2 = trimPath(*(char * const *) pathname2);
1208 return strcmp(s1, s2);
1209}
1210
1211static void
1212makeUniqueMirroredDestDirs(char** srcDirNames, unsigned nbFile, const char* outDirName)
1213{
1214 unsigned int i = 0, uniqueDirNr = 0;
1215 char** uniqueDirNames = NULL;
1216
1217 if (nbFile == 0)
1218 return;
1219
1220 uniqueDirNames = (char** ) malloc(nbFile * sizeof (char *));
1221 CONTROL(uniqueDirNames != NULL);
1222
1223 /* if dirs is "a/b/c" and "a/b/c/d", we only need call:
1224 * we just need "a/b/c/d" */
1225 qsort((void *)srcDirNames, nbFile, sizeof(char*), compareDir);
1226
1227 uniqueDirNr = 1;
1228 uniqueDirNames[uniqueDirNr - 1] = srcDirNames[0];
1229 for (i = 1; i < nbFile; i++) {
1230 char* prevDirName = srcDirNames[i - 1];
1231 char* currDirName = srcDirNames[i];
1232
1233 /* note: we always compare trimmed path, i.e.:
1234 * src dir of "./foo" and "/foo" will be both saved into:
1235 * "outDirName/foo/" */
1236 if (!firstIsParentOrSameDirOfSecond(trimPath(prevDirName),
1237 trimPath(currDirName)))
1238 uniqueDirNr++;
1239
1240 /* we need to maintain original src dir name instead of trimmed
1241 * dir, so we can retrieve the original src dir's mode_t */
1242 uniqueDirNames[uniqueDirNr - 1] = currDirName;
1243 }
1244
1245 makeMirroredDestDirsWithSameSrcDirMode(uniqueDirNames, uniqueDirNr, outDirName);
1246
1247 free(uniqueDirNames);
1248}
1249
1250static void
1251makeMirroredDestDirs(char** srcFileNames, unsigned nbFile, const char* outDirName)
1252{
1253 unsigned int i = 0;
1254 for (i = 0; i < nbFile; ++i)
1255 convertPathnameToDirName(srcFileNames[i]);
1256 makeUniqueMirroredDestDirs(srcFileNames, nbFile, outDirName);
1257}
1258
1259void UTIL_mirrorSourceFilesDirectories(const char** inFileNames, unsigned int nbFile, const char* outDirName)
1260{
1261 unsigned int i = 0, validFilenamesNr = 0;
1262 char** srcFileNames = (char **) malloc(nbFile * sizeof (char *));
1263 CONTROL(srcFileNames != NULL);
1264
1265 /* check input filenames is valid */
1266 for (i = 0; i < nbFile; ++i) {
1267 if (isFileNameValidForMirroredOutput(inFileNames[i])) {
1268 char* fname = STRDUP(inFileNames[i]);
1269 CONTROL(fname != NULL);
1270 srcFileNames[validFilenamesNr++] = fname;
1271 }
1272 }
1273
1274 if (validFilenamesNr > 0) {
1275 makeDir(outDirName, DIR_DEFAULT_MODE);
1276 makeMirroredDestDirs(srcFileNames, validFilenamesNr, outDirName);
1277 }
1278
1279 for (i = 0; i < validFilenamesNr; i++)
1280 free(srcFileNames[i]);
1281 free(srcFileNames);
1282}
1283
1284FileNamesTable*
1285UTIL_createExpandedFNT(const char* const* inputNames, size_t nbIfns, int followLinks)
1286{
1287 unsigned nbFiles;
1288 char* buf = (char*)malloc(LIST_SIZE_INCREASE);
1289 char* bufend = buf + LIST_SIZE_INCREASE;
1290
1291 if (!buf) return NULL;
1292
1293 { size_t ifnNb, pos;
1294 for (ifnNb=0, pos=0, nbFiles=0; ifnNb<nbIfns; ifnNb++) {
1295 if (!UTIL_isDirectory(inputNames[ifnNb])) {
1296 size_t const len = strlen(inputNames[ifnNb]);
1297 if (buf + pos + len >= bufend) {
1298 ptrdiff_t newListSize = (bufend - buf) + LIST_SIZE_INCREASE;
1299 assert(newListSize >= 0);
1300 buf = (char*)UTIL_realloc(buf, (size_t)newListSize);
1301 if (!buf) return NULL;
1302 bufend = buf + newListSize;
1303 }
1304 if (buf + pos + len < bufend) {
1305 memcpy(buf+pos, inputNames[ifnNb], len+1); /* including final \0 */
1306 pos += len + 1;
1307 nbFiles++;
1308 }
1309 } else {
1310 nbFiles += (unsigned)UTIL_prepareFileList(inputNames[ifnNb], &buf, &pos, &bufend, followLinks);
1311 if (buf == NULL) return NULL;
1312 } } }
1313
1314 /* note : even if nbFiles==0, function returns a valid, though empty, FileNamesTable* object */
1315
1316 { size_t ifnNb, pos;
1317 size_t const fntCapacity = nbFiles + 1; /* minimum 1, allows adding one reference, typically stdin */
1318 const char** const fileNamesTable = (const char**)malloc(fntCapacity * sizeof(*fileNamesTable));
1319 if (!fileNamesTable) { free(buf); return NULL; }
1320
1321 for (ifnNb = 0, pos = 0; ifnNb < nbFiles; ifnNb++) {
1322 fileNamesTable[ifnNb] = buf + pos;
1323 if (buf + pos > bufend) { free(buf); free((void*)fileNamesTable); return NULL; }
1324 pos += strlen(fileNamesTable[ifnNb]) + 1;
1325 }
1326 return UTIL_assembleFileNamesTable2(fileNamesTable, nbFiles, fntCapacity, buf);
1327 }
1328}
1329
1330
1331void UTIL_expandFNT(FileNamesTable** fnt, int followLinks)
1332{
1333 FileNamesTable* const newFNT = UTIL_createExpandedFNT((*fnt)->fileNames, (*fnt)->tableSize, followLinks);
1334 CONTROL(newFNT != NULL);
1335 UTIL_freeFileNamesTable(*fnt);
1336 *fnt = newFNT;
1337}
1338
1339FileNamesTable* UTIL_createFNT_fromROTable(const char** filenames, size_t nbFilenames)
1340{
1341 size_t const sizeof_FNTable = nbFilenames * sizeof(*filenames);
1342 const char** const newFNTable = (const char**)malloc(sizeof_FNTable);
1343 if (newFNTable==NULL) return NULL;
1344 memcpy((void*)newFNTable, filenames, sizeof_FNTable); /* void* : mitigate a Visual compiler bug or limitation */
1345 return UTIL_assembleFileNamesTable(newFNTable, nbFilenames, NULL);
1346}
1347
1348
1349/*-****************************************
1350* count the number of cores
1351******************************************/
1352
1353#if defined(_WIN32) || defined(WIN32)
1354
1355#include <windows.h>
1356
1357typedef BOOL(WINAPI* LPFN_GLPI)(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, PDWORD);
1358
1359DWORD CountSetBits(ULONG_PTR bitMask)
1360{
1361 DWORD LSHIFT = sizeof(ULONG_PTR)*8 - 1;
1362 DWORD bitSetCount = 0;
1363 ULONG_PTR bitTest = (ULONG_PTR)1 << LSHIFT;
1364 DWORD i;
1365
1366 for (i = 0; i <= LSHIFT; ++i)
1367 {
1368 bitSetCount += ((bitMask & bitTest)?1:0);
1369 bitTest/=2;
1370 }
1371
1372 return bitSetCount;
1373}
1374
1375int UTIL_countCores(int logical)
1376{
1377 static int numCores = 0;
1378 if (numCores != 0) return numCores;
1379
1380 { LPFN_GLPI glpi;
1381 BOOL done = FALSE;
1382 PSYSTEM_LOGICAL_PROCESSOR_INFORMATION buffer = NULL;
1383 PSYSTEM_LOGICAL_PROCESSOR_INFORMATION ptr = NULL;
1384 DWORD returnLength = 0;
1385 size_t byteOffset = 0;
1386
1387#if defined(_MSC_VER)
1388/* Visual Studio does not like the following cast */
1389# pragma warning( disable : 4054 ) /* conversion from function ptr to data ptr */
1390# pragma warning( disable : 4055 ) /* conversion from data ptr to function ptr */
1391#endif
1392 glpi = (LPFN_GLPI)(void*)GetProcAddress(GetModuleHandle(TEXT("kernel32")),
1393 "GetLogicalProcessorInformation");
1394
1395 if (glpi == NULL) {
1396 goto failed;
1397 }
1398
1399 while(!done) {
1400 DWORD rc = glpi(buffer, &returnLength);
1401 if (FALSE == rc) {
1402 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
1403 if (buffer)
1404 free(buffer);
1405 buffer = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)malloc(returnLength);
1406
1407 if (buffer == NULL) {
1408 perror("zstd");
1409 exit(1);
1410 }
1411 } else {
1412 /* some other error */
1413 goto failed;
1414 }
1415 } else {
1416 done = TRUE;
1417 } }
1418
1419 ptr = buffer;
1420
1421 while (byteOffset + sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION) <= returnLength) {
1422
1423 if (ptr->Relationship == RelationProcessorCore) {
1424 if (logical)
1425 numCores += CountSetBits(ptr->ProcessorMask);
1426 else
1427 numCores++;
1428 }
1429
1430 ptr++;
1431 byteOffset += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
1432 }
1433
1434 free(buffer);
1435
1436 return numCores;
1437 }
1438
1439failed:
1440 /* try to fall back on GetSystemInfo */
1441 { SYSTEM_INFO sysinfo;
1442 GetSystemInfo(&sysinfo);
1443 numCores = sysinfo.dwNumberOfProcessors;
1444 if (numCores == 0) numCores = 1; /* just in case */
1445 }
1446 return numCores;
1447}
1448
1449#elif defined(__APPLE__)
1450
1451#include <sys/sysctl.h>
1452
1453/* Use apple-provided syscall
1454 * see: man 3 sysctl */
1455int UTIL_countCores(int logical)
1456{
1457 static S32 numCores = 0; /* apple specifies int32_t */
1458 if (numCores != 0) return numCores;
1459
1460 { size_t size = sizeof(S32);
1461 int const ret = sysctlbyname(logical ? "hw.logicalcpu" : "hw.physicalcpu", &numCores, &size, NULL, 0);
1462 if (ret != 0) {
1463 if (errno == ENOENT) {
1464 /* entry not present, fall back on 1 */
1465 numCores = 1;
1466 } else {
1467 perror("zstd: can't get number of cpus");
1468 exit(1);
1469 }
1470 }
1471
1472 return numCores;
1473 }
1474}
1475
1476#elif defined(__linux__)
1477
1478/* parse /proc/cpuinfo
1479 * siblings / cpu cores should give hyperthreading ratio
1480 * otherwise fall back on sysconf */
1481int UTIL_countCores(int logical)
1482{
1483 static int numCores = 0;
1484
1485 if (numCores != 0) return numCores;
1486
1487 numCores = (int)sysconf(_SC_NPROCESSORS_ONLN);
1488 if (numCores == -1) {
1489 /* value not queryable, fall back on 1 */
1490 return numCores = 1;
1491 }
1492
1493 /* try to determine if there's hyperthreading */
1494 { FILE* const cpuinfo = fopen("/proc/cpuinfo", "r");
1495#define BUF_SIZE 80
1496 char buff[BUF_SIZE];
1497
1498 int siblings = 0;
1499 int cpu_cores = 0;
1500 int ratio = 1;
1501
1502 if (cpuinfo == NULL) {
1503 /* fall back on the sysconf value */
1504 return numCores;
1505 }
1506
1507 /* assume the cpu cores/siblings values will be constant across all
1508 * present processors */
1509 while (!feof(cpuinfo)) {
1510 if (fgets(buff, BUF_SIZE, cpuinfo) != NULL) {
1511 if (strncmp(buff, "siblings", 8) == 0) {
1512 const char* const sep = strchr(buff, ':');
1513 if (sep == NULL || *sep == '\0') {
1514 /* formatting was broken? */
1515 goto failed;
1516 }
1517
1518 siblings = atoi(sep + 1);
1519 }
1520 if (strncmp(buff, "cpu cores", 9) == 0) {
1521 const char* const sep = strchr(buff, ':');
1522 if (sep == NULL || *sep == '\0') {
1523 /* formatting was broken? */
1524 goto failed;
1525 }
1526
1527 cpu_cores = atoi(sep + 1);
1528 }
1529 } else if (ferror(cpuinfo)) {
1530 /* fall back on the sysconf value */
1531 goto failed;
1532 } }
1533 if (siblings && cpu_cores && siblings > cpu_cores) {
1534 ratio = siblings / cpu_cores;
1535 }
1536
1537 if (ratio && numCores > ratio && !logical) {
1538 numCores = numCores / ratio;
1539 }
1540
1541failed:
1542 fclose(cpuinfo);
1543 return numCores;
1544 }
1545}
1546
1547#elif defined(__FreeBSD__)
1548
1549#include <sys/param.h>
1550#include <sys/sysctl.h>
1551
1552/* Use physical core sysctl when available
1553 * see: man 4 smp, man 3 sysctl */
1554int UTIL_countCores(int logical)
1555{
1556 static int numCores = 0; /* freebsd sysctl is native int sized */
1557#if __FreeBSD_version >= 1300008
1558 static int perCore = 1;
1559#endif
1560 if (numCores != 0) return numCores;
1561
1562#if __FreeBSD_version >= 1300008
1563 { size_t size = sizeof(numCores);
1564 int ret = sysctlbyname("kern.smp.cores", &numCores, &size, NULL, 0);
1565 if (ret == 0) {
1566 if (logical) {
1567 ret = sysctlbyname("kern.smp.threads_per_core", &perCore, &size, NULL, 0);
1568 /* default to physical cores if logical cannot be read */
1569 if (ret == 0)
1570 numCores *= perCore;
1571 }
1572
1573 return numCores;
1574 }
1575 if (errno != ENOENT) {
1576 perror("zstd: can't get number of cpus");
1577 exit(1);
1578 }
1579 /* sysctl not present, fall through to older sysconf method */
1580 }
1581#else
1582 /* suppress unused parameter warning */
1583 (void) logical;
1584#endif
1585
1586 numCores = (int)sysconf(_SC_NPROCESSORS_ONLN);
1587 if (numCores == -1) {
1588 /* value not queryable, fall back on 1 */
1589 numCores = 1;
1590 }
1591 return numCores;
1592}
1593
1594#elif defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__CYGWIN__)
1595
1596/* Use POSIX sysconf
1597 * see: man 3 sysconf */
1598int UTIL_countCores(int logical)
1599{
1600 static int numCores = 0;
1601
1602 /* suppress unused parameter warning */
1603 (void)logical;
1604
1605 if (numCores != 0) return numCores;
1606
1607 numCores = (int)sysconf(_SC_NPROCESSORS_ONLN);
1608 if (numCores == -1) {
1609 /* value not queryable, fall back on 1 */
1610 return numCores = 1;
1611 }
1612 return numCores;
1613}
1614
1615#else
1616
1617int UTIL_countCores(int logical)
1618{
1619 /* suppress unused parameter warning */
1620 (void)logical;
1621
1622 /* assume 1 */
1623 return 1;
1624}
1625
1626#endif
1627
1628int UTIL_countPhysicalCores(void)
1629{
1630 return UTIL_countCores(0);
1631}
1632
1633int UTIL_countLogicalCores(void)
1634{
1635 return UTIL_countCores(1);
1636}
1637
1638#if defined (__cplusplus)
1639}
1640#endif
ARM optimized PCSX fork