| 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 | #ifndef UTIL_H_MODULE |
| 12 | #define UTIL_H_MODULE |
| 13 | |
| 14 | #if defined (__cplusplus) |
| 15 | extern "C" { |
| 16 | #endif |
| 17 | |
| 18 | |
| 19 | /*-**************************************** |
| 20 | * Dependencies |
| 21 | ******************************************/ |
| 22 | #include "platform.h" /* PLATFORM_POSIX_VERSION, ZSTD_NANOSLEEP_SUPPORT, ZSTD_SETPRIORITY_SUPPORT */ |
| 23 | #include <stddef.h> /* size_t, ptrdiff_t */ |
| 24 | #include <sys/types.h> /* stat, utime */ |
| 25 | #include <sys/stat.h> /* stat, chmod */ |
| 26 | #include "../lib/common/mem.h" /* U64 */ |
| 27 | |
| 28 | |
| 29 | /*-************************************************************ |
| 30 | * Avoid fseek()'s 2GiB barrier with MSVC, macOS, *BSD, MinGW |
| 31 | ***************************************************************/ |
| 32 | #if defined(_MSC_VER) && (_MSC_VER >= 1400) |
| 33 | # define UTIL_fseek _fseeki64 |
| 34 | #elif !defined(__64BIT__) && (PLATFORM_POSIX_VERSION >= 200112L) /* No point defining Large file for 64 bit */ |
| 35 | # define UTIL_fseek fseeko |
| 36 | #elif defined(__MINGW32__) && defined(__MSVCRT__) && !defined(__STRICT_ANSI__) && !defined(__NO_MINGW_LFS) |
| 37 | # define UTIL_fseek fseeko64 |
| 38 | #else |
| 39 | # define UTIL_fseek fseek |
| 40 | #endif |
| 41 | |
| 42 | |
| 43 | /*-************************************************* |
| 44 | * Sleep & priority functions: Windows - Posix - others |
| 45 | ***************************************************/ |
| 46 | #if defined(_WIN32) |
| 47 | # include <windows.h> |
| 48 | # define SET_REALTIME_PRIORITY SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS) |
| 49 | # define UTIL_sleep(s) Sleep(1000*s) |
| 50 | # define UTIL_sleepMilli(milli) Sleep(milli) |
| 51 | |
| 52 | #elif PLATFORM_POSIX_VERSION > 0 /* Unix-like operating system */ |
| 53 | # include <unistd.h> /* sleep */ |
| 54 | # define UTIL_sleep(s) sleep(s) |
| 55 | # if ZSTD_NANOSLEEP_SUPPORT /* necessarily defined in platform.h */ |
| 56 | # define UTIL_sleepMilli(milli) { struct timespec t; t.tv_sec=0; t.tv_nsec=milli*1000000ULL; nanosleep(&t, NULL); } |
| 57 | # else |
| 58 | # define UTIL_sleepMilli(milli) /* disabled */ |
| 59 | # endif |
| 60 | # if ZSTD_SETPRIORITY_SUPPORT |
| 61 | # include <sys/resource.h> /* setpriority */ |
| 62 | # define SET_REALTIME_PRIORITY setpriority(PRIO_PROCESS, 0, -20) |
| 63 | # else |
| 64 | # define SET_REALTIME_PRIORITY /* disabled */ |
| 65 | # endif |
| 66 | |
| 67 | #else /* unknown non-unix operating system */ |
| 68 | # define UTIL_sleep(s) /* disabled */ |
| 69 | # define UTIL_sleepMilli(milli) /* disabled */ |
| 70 | # define SET_REALTIME_PRIORITY /* disabled */ |
| 71 | #endif |
| 72 | |
| 73 | |
| 74 | /*-**************************************** |
| 75 | * Compiler specifics |
| 76 | ******************************************/ |
| 77 | #if defined(__INTEL_COMPILER) |
| 78 | # pragma warning(disable : 177) /* disable: message #177: function was declared but never referenced, useful with UTIL_STATIC */ |
| 79 | #endif |
| 80 | #if defined(__GNUC__) |
| 81 | # define UTIL_STATIC static __attribute__((unused)) |
| 82 | #elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) |
| 83 | # define UTIL_STATIC static inline |
| 84 | #elif defined(_MSC_VER) |
| 85 | # define UTIL_STATIC static __inline |
| 86 | #else |
| 87 | # define UTIL_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */ |
| 88 | #endif |
| 89 | |
| 90 | |
| 91 | /*-**************************************** |
| 92 | * Console log |
| 93 | ******************************************/ |
| 94 | extern int g_utilDisplayLevel; |
| 95 | |
| 96 | /** |
| 97 | * Displays a message prompt and returns success (0) if first character from stdin |
| 98 | * matches any from acceptableLetters. Otherwise, returns failure (1) and displays abortMsg. |
| 99 | * If any of the inputs are stdin itself, then automatically return failure (1). |
| 100 | */ |
| 101 | int UTIL_requireUserConfirmation(const char* prompt, const char* abortMsg, const char* acceptableLetters, int hasStdinInput); |
| 102 | |
| 103 | |
| 104 | /*-**************************************** |
| 105 | * File functions |
| 106 | ******************************************/ |
| 107 | #if defined(_MSC_VER) |
| 108 | typedef struct __stat64 stat_t; |
| 109 | typedef int mode_t; |
| 110 | #elif defined(__MINGW32__) && defined (__MSVCRT__) |
| 111 | typedef struct _stati64 stat_t; |
| 112 | #else |
| 113 | typedef struct stat stat_t; |
| 114 | #endif |
| 115 | |
| 116 | #if defined(_MSC_VER) || defined(__MINGW32__) || defined (__MSVCRT__) /* windows support */ |
| 117 | #define PATH_SEP '\\' |
| 118 | #define STRDUP(s) _strdup(s) |
| 119 | #else |
| 120 | #define PATH_SEP '/' |
| 121 | #include <libgen.h> |
| 122 | #define STRDUP(s) strdup(s) |
| 123 | #endif |
| 124 | |
| 125 | |
| 126 | /** |
| 127 | * Calls platform's equivalent of stat() on filename and writes info to statbuf. |
| 128 | * Returns success (1) or failure (0). |
| 129 | * |
| 130 | * UTIL_fstat() is like UTIL_stat() but takes an optional fd that refers to the |
| 131 | * file in question. It turns out that this can be meaningfully faster. If fd is |
| 132 | * -1, behaves just like UTIL_stat() (i.e., falls back to using the filename). |
| 133 | */ |
| 134 | int UTIL_stat(const char* filename, stat_t* statbuf); |
| 135 | int UTIL_fstat(const int fd, const char* filename, stat_t* statbuf); |
| 136 | |
| 137 | /** |
| 138 | * Instead of getting a file's stats, this updates them with the info in the |
| 139 | * provided stat_t. Currently sets owner, group, atime, and mtime. Will only |
| 140 | * update this info for regular files. |
| 141 | * |
| 142 | * UTIL_setFDStat() also takes an fd, and will preferentially use that to |
| 143 | * indicate which file to modify, If fd is -1, it will fall back to using the |
| 144 | * filename. |
| 145 | */ |
| 146 | int UTIL_setFileStat(const char* filename, const stat_t* statbuf); |
| 147 | int UTIL_setFDStat(const int fd, const char* filename, const stat_t* statbuf); |
| 148 | |
| 149 | /** |
| 150 | * Set atime to now and mtime to the st_mtim in statbuf. |
| 151 | * |
| 152 | * Directly wraps utime() or utimensat(). Returns -1 on error. |
| 153 | * Does not validate filename is valid. |
| 154 | */ |
| 155 | int UTIL_utime(const char* filename, const stat_t *statbuf); |
| 156 | |
| 157 | /* |
| 158 | * These helpers operate on a pre-populated stat_t, i.e., the result of |
| 159 | * calling one of the above functions. |
| 160 | */ |
| 161 | |
| 162 | int UTIL_isRegularFileStat(const stat_t* statbuf); |
| 163 | int UTIL_isDirectoryStat(const stat_t* statbuf); |
| 164 | int UTIL_isFIFOStat(const stat_t* statbuf); |
| 165 | int UTIL_isBlockDevStat(const stat_t* statbuf); |
| 166 | U64 UTIL_getFileSizeStat(const stat_t* statbuf); |
| 167 | |
| 168 | /** |
| 169 | * Like chmod(), but only modifies regular files. Provided statbuf may be NULL, |
| 170 | * in which case this function will stat() the file internally, in order to |
| 171 | * check whether it should be modified. |
| 172 | * |
| 173 | * If fd is -1, fd is ignored and the filename is used. |
| 174 | */ |
| 175 | int UTIL_chmod(char const* filename, const stat_t* statbuf, mode_t permissions); |
| 176 | int UTIL_fchmod(const int fd, char const* filename, const stat_t* statbuf, mode_t permissions); |
| 177 | |
| 178 | /* |
| 179 | * In the absence of a pre-existing stat result on the file in question, these |
| 180 | * functions will do a stat() call internally and then use that result to |
| 181 | * compute the needed information. |
| 182 | */ |
| 183 | |
| 184 | int UTIL_isRegularFile(const char* infilename); |
| 185 | int UTIL_isDirectory(const char* infilename); |
| 186 | int UTIL_isSameFile(const char* file1, const char* file2); |
| 187 | int UTIL_isSameFileStat(const char* file1, const char* file2, const stat_t* file1Stat, const stat_t* file2Stat); |
| 188 | int UTIL_isCompressedFile(const char* infilename, const char *extensionList[]); |
| 189 | int UTIL_isLink(const char* infilename); |
| 190 | int UTIL_isFIFO(const char* infilename); |
| 191 | |
| 192 | /** |
| 193 | * Returns with the given file descriptor is a console. |
| 194 | * Allows faking whether stdin/stdout/stderr is a console |
| 195 | * using UTIL_fake*IsConsole(). |
| 196 | */ |
| 197 | int UTIL_isConsole(FILE* file); |
| 198 | |
| 199 | /** |
| 200 | * Pretends that stdin/stdout/stderr is a console for testing. |
| 201 | */ |
| 202 | void UTIL_fakeStdinIsConsole(void); |
| 203 | void UTIL_fakeStdoutIsConsole(void); |
| 204 | void UTIL_fakeStderrIsConsole(void); |
| 205 | |
| 206 | /** |
| 207 | * Emit traces for functions that read, or modify file metadata. |
| 208 | */ |
| 209 | void UTIL_traceFileStat(void); |
| 210 | |
| 211 | #define UTIL_FILESIZE_UNKNOWN ((U64)(-1)) |
| 212 | U64 UTIL_getFileSize(const char* infilename); |
| 213 | U64 UTIL_getTotalFileSize(const char* const * fileNamesTable, unsigned nbFiles); |
| 214 | |
| 215 | /** |
| 216 | * Take @size in bytes, |
| 217 | * prepare the components to pretty-print it in a scaled way. |
| 218 | * The components in the returned struct should be passed in |
| 219 | * precision, value, suffix order to a "%.*f%s" format string. |
| 220 | * Output policy is sensible to @g_utilDisplayLevel, |
| 221 | * for verbose mode (@g_utilDisplayLevel >= 4), |
| 222 | * does not scale down. |
| 223 | */ |
| 224 | typedef struct { |
| 225 | double value; |
| 226 | int precision; |
| 227 | const char* suffix; |
| 228 | } UTIL_HumanReadableSize_t; |
| 229 | |
| 230 | UTIL_HumanReadableSize_t UTIL_makeHumanReadableSize(U64 size); |
| 231 | |
| 232 | int UTIL_compareStr(const void *p1, const void *p2); |
| 233 | const char* UTIL_getFileExtension(const char* infilename); |
| 234 | void UTIL_mirrorSourceFilesDirectories(const char** fileNamesTable, unsigned int nbFiles, const char *outDirName); |
| 235 | char* UTIL_createMirroredDestDirName(const char* srcFileName, const char* outDirRootName); |
| 236 | |
| 237 | |
| 238 | |
| 239 | /*-**************************************** |
| 240 | * Lists of Filenames |
| 241 | ******************************************/ |
| 242 | |
| 243 | typedef struct |
| 244 | { const char** fileNames; |
| 245 | char* buf; /* fileNames are stored in this buffer (or are read-only) */ |
| 246 | size_t tableSize; /* nb of fileNames */ |
| 247 | size_t tableCapacity; |
| 248 | } FileNamesTable; |
| 249 | |
| 250 | /*! UTIL_createFileNamesTable_fromFileName() : |
| 251 | * read filenames from @inputFileName, and store them into returned object. |
| 252 | * @return : a FileNamesTable*, or NULL in case of error (ex: @inputFileName doesn't exist). |
| 253 | * Note: inputFileSize must be less than 50MB |
| 254 | */ |
| 255 | FileNamesTable* |
| 256 | UTIL_createFileNamesTable_fromFileName(const char* inputFileName); |
| 257 | |
| 258 | /*! UTIL_assembleFileNamesTable() : |
| 259 | * This function takes ownership of its arguments, @filenames and @buf, |
| 260 | * and store them inside the created object. |
| 261 | * note : this function never fails, |
| 262 | * it will rather exit() the program if internal allocation fails. |
| 263 | * @return : resulting FileNamesTable* object. |
| 264 | */ |
| 265 | FileNamesTable* |
| 266 | UTIL_assembleFileNamesTable(const char** filenames, size_t tableSize, char* buf); |
| 267 | |
| 268 | /*! UTIL_freeFileNamesTable() : |
| 269 | * This function is compatible with NULL argument and never fails. |
| 270 | */ |
| 271 | void UTIL_freeFileNamesTable(FileNamesTable* table); |
| 272 | |
| 273 | /*! UTIL_mergeFileNamesTable(): |
| 274 | * @return : FileNamesTable*, concatenation of @table1 and @table2 |
| 275 | * note: @table1 and @table2 are consumed (freed) by this operation |
| 276 | */ |
| 277 | FileNamesTable* |
| 278 | UTIL_mergeFileNamesTable(FileNamesTable* table1, FileNamesTable* table2); |
| 279 | |
| 280 | |
| 281 | /*! UTIL_expandFNT() : |
| 282 | * read names from @fnt, and expand those corresponding to directories |
| 283 | * update @fnt, now containing only file names, |
| 284 | * note : in case of error, @fnt[0] is NULL |
| 285 | */ |
| 286 | void UTIL_expandFNT(FileNamesTable** fnt, int followLinks); |
| 287 | |
| 288 | /*! UTIL_createFNT_fromROTable() : |
| 289 | * copy the @filenames pointer table inside the returned object. |
| 290 | * The names themselves are still stored in their original buffer, which must outlive the object. |
| 291 | * @return : a FileNamesTable* object, |
| 292 | * or NULL in case of error |
| 293 | */ |
| 294 | FileNamesTable* |
| 295 | UTIL_createFNT_fromROTable(const char** filenames, size_t nbFilenames); |
| 296 | |
| 297 | /*! UTIL_allocateFileNamesTable() : |
| 298 | * Allocates a table of const char*, to insert read-only names later on. |
| 299 | * The created FileNamesTable* doesn't hold a buffer. |
| 300 | * @return : FileNamesTable*, or NULL, if allocation fails. |
| 301 | */ |
| 302 | FileNamesTable* UTIL_allocateFileNamesTable(size_t tableSize); |
| 303 | |
| 304 | /*! UTIL_searchFileNamesTable() : |
| 305 | * Searched through entries in FileNamesTable for a specific name. |
| 306 | * @return : index of entry if found or -1 if not found |
| 307 | */ |
| 308 | int UTIL_searchFileNamesTable(FileNamesTable* table, char const* name); |
| 309 | |
| 310 | /*! UTIL_refFilename() : |
| 311 | * Add a reference to read-only name into @fnt table. |
| 312 | * As @filename is only referenced, its lifetime must outlive @fnt. |
| 313 | * Internal table must be large enough to reference a new member, |
| 314 | * otherwise its UB (protected by an `assert()`). |
| 315 | */ |
| 316 | void UTIL_refFilename(FileNamesTable* fnt, const char* filename); |
| 317 | |
| 318 | |
| 319 | /* UTIL_createExpandedFNT() is only active if UTIL_HAS_CREATEFILELIST is defined. |
| 320 | * Otherwise, UTIL_createExpandedFNT() is a shell function which does nothing |
| 321 | * apart from displaying a warning message. |
| 322 | */ |
| 323 | #ifdef _WIN32 |
| 324 | # define UTIL_HAS_CREATEFILELIST |
| 325 | #elif defined(__linux__) || (PLATFORM_POSIX_VERSION >= 200112L) /* opendir, readdir require POSIX.1-2001 */ |
| 326 | # define UTIL_HAS_CREATEFILELIST |
| 327 | # define UTIL_HAS_MIRRORFILELIST |
| 328 | #else |
| 329 | /* do not define UTIL_HAS_CREATEFILELIST */ |
| 330 | #endif |
| 331 | |
| 332 | /*! UTIL_createExpandedFNT() : |
| 333 | * read names from @filenames, and expand those corresponding to directories. |
| 334 | * links are followed or not depending on @followLinks directive. |
| 335 | * @return : an expanded FileNamesTable*, where each name is a file |
| 336 | * or NULL in case of error |
| 337 | */ |
| 338 | FileNamesTable* |
| 339 | UTIL_createExpandedFNT(const char* const* filenames, size_t nbFilenames, int followLinks); |
| 340 | |
| 341 | #if defined(_WIN32) |
| 342 | DWORD CountSetBits(ULONG_PTR bitMask); |
| 343 | #endif |
| 344 | |
| 345 | /*-**************************************** |
| 346 | * System |
| 347 | ******************************************/ |
| 348 | |
| 349 | int UTIL_countCores(int logical); |
| 350 | |
| 351 | int UTIL_countPhysicalCores(void); |
| 352 | |
| 353 | int UTIL_countLogicalCores(void); |
| 354 | |
| 355 | #if defined (__cplusplus) |
| 356 | } |
| 357 | #endif |
| 358 | |
| 359 | #endif /* UTIL_H_MODULE */ |