git-compat-util.h

   1 #ifndef GIT_COMPAT_UTIL_H
   2 #define GIT_COMPAT_UTIL_H
   3
   4 #if __STDC_VERSION__ - 0 < 199901L
   5 /*
   6  * Git is in a testing period for mandatory C99 support in the compiler.  If
   7  * your compiler is reasonably recent, you can try to enable C99 support (or,
   8  * for MSVC, C11 support).  If you encounter a problem and can't enable C99
   9  * support with your compiler (such as with "-std=gnu99") and don't have access
  10  * to one with this support, such as GCC or Clang, you can remove this #if
  11  * directive, but please report the details of your system to
  12  * git@vger.kernel.org.
  13  */
  14 #error "Required C99 support is in a test phase.  Please see git-compat-util.h for more details."
  15 #endif
  16
  17 #ifdef USE_MSVC_CRTDBG
  18 /*
  19  * For these to work they must appear very early in each
  20  * file -- before most of the standard header files.
  21  */
  22 #include <stdlib.h>
  23 #include <crtdbg.h>
  24 #endif
  25
  26 #define _FILE_OFFSET_BITS 64
  27
  28
  29 /* Derived from Linux "Features Test Macro" header
  30  * Convenience macros to test the versions of gcc (or
  31  * a compatible compiler).
  32  * Use them like this:
  33  *  #if GIT_GNUC_PREREQ (2,8)
  34  *   ... code requiring gcc 2.8 or later ...
  35  *  #endif
  36 */
  37 #if defined(__GNUC__) && defined(__GNUC_MINOR__)
  38 # define GIT_GNUC_PREREQ(maj, min) \
  39         ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
  40 #else
  41  #define GIT_GNUC_PREREQ(maj, min) 0
  42 #endif
  43
  44
  45 #ifndef FLEX_ARRAY
  46 /*
  47  * See if our compiler is known to support flexible array members.
  48  */
  49
  50 /*
  51  * Check vendor specific quirks first, before checking the
  52  * __STDC_VERSION__, as vendor compilers can lie and we need to be
  53  * able to work them around.  Note that by not defining FLEX_ARRAY
  54  * here, we can fall back to use the "safer but a bit wasteful" one
  55  * later.
  56  */
  57 #if defined(__SUNPRO_C) && (__SUNPRO_C <= 0x580)
  58 #elif defined(__GNUC__)
  59 # if (__GNUC__ >= 3)
  60 #  define FLEX_ARRAY /* empty */
  61 # else
  62 #  define FLEX_ARRAY 0 /* older GNU extension */
  63 # endif
  64 #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
  65 # define FLEX_ARRAY /* empty */
  66 #endif
  67
  68 /*
  69  * Otherwise, default to safer but a bit wasteful traditional style
  70  */
  71 #ifndef FLEX_ARRAY
  72 # define FLEX_ARRAY 1
  73 #endif
  74 #endif
  75
  76
  77 /*
  78  * BUILD_ASSERT_OR_ZERO - assert a build-time dependency, as an expression.
  79  * @cond: the compile-time condition which must be true.
  80  *
  81  * Your compile will fail if the condition isn't true, or can't be evaluated
  82  * by the compiler.  This can be used in an expression: its value is "0".
  83  *
  84  * Example:
  85  *      #define foo_to_char(foo)                                        \
  86  *               ((char *)(foo)                                         \
  87  *                + BUILD_ASSERT_OR_ZERO(offsetof(struct foo, string) == 0))
  88  */
  89 #define BUILD_ASSERT_OR_ZERO(cond) \
  90         (sizeof(char [1 - 2*!(cond)]) - 1)
  91
  92 #if GIT_GNUC_PREREQ(3, 1)
  93  /* &arr[0] degrades to a pointer: a different type from an array */
  94 # define BARF_UNLESS_AN_ARRAY(arr)                                              \
  95         BUILD_ASSERT_OR_ZERO(!__builtin_types_compatible_p(__typeof__(arr), \
  96                                                            __typeof__(&(arr)[0])))
  97 #else
  98 # define BARF_UNLESS_AN_ARRAY(arr) 0
  99 #endif
 100 /*
 101  * ARRAY_SIZE - get the number of elements in a visible array
 102  * @x: the array whose size you want.
 103  *
 104  * This does not work on pointers, or arrays declared as [], or
 105  * function parameters.  With correct compiler support, such usage
 106  * will cause a build error (see the build_assert_or_zero macro).
 107  */
 108 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]) + BARF_UNLESS_AN_ARRAY(x))
 109
 110 #define bitsizeof(x)  (CHAR_BIT * sizeof(x))
 111
 112 #define maximum_signed_value_of_type(a) \
 113     (INTMAX_MAX >> (bitsizeof(intmax_t) - bitsizeof(a)))
 114
 115 #define maximum_unsigned_value_of_type(a) \
 116     (UINTMAX_MAX >> (bitsizeof(uintmax_t) - bitsizeof(a)))
 117
 118 /*
 119  * Signed integer overflow is undefined in C, so here's a helper macro
 120  * to detect if the sum of two integers will overflow.
 121  *
 122  * Requires: a >= 0, typeof(a) equals typeof(b)
 123  */
 124 #define signed_add_overflows(a, b) \
 125     ((b) > maximum_signed_value_of_type(a) - (a))
 126
 127 #define unsigned_add_overflows(a, b) \
 128     ((b) > maximum_unsigned_value_of_type(a) - (a))
 129
 130 /*
 131  * Returns true if the multiplication of "a" and "b" will
 132  * overflow. The types of "a" and "b" must match and must be unsigned.
 133  * Note that this macro evaluates "a" twice!
 134  */
 135 #define unsigned_mult_overflows(a, b) \
 136     ((a) && (b) > maximum_unsigned_value_of_type(a) / (a))
 137
 138 /*
 139  * Returns true if the left shift of "a" by "shift" bits will
 140  * overflow. The type of "a" must be unsigned.
 141  */
 142 #define unsigned_left_shift_overflows(a, shift) \
 143     ((shift) < bitsizeof(a) && \
 144      (a) > maximum_unsigned_value_of_type(a) >> (shift))
 145
 146 #ifdef __GNUC__
 147 #define TYPEOF(x) (__typeof__(x))
 148 #else
 149 #define TYPEOF(x)
 150 #endif
 151
 152 #define MSB(x, bits) ((x) & TYPEOF(x)(~0ULL << (bitsizeof(x) - (bits))))
 153 #define HAS_MULTI_BITS(i)  ((i) & ((i) - 1))  /* checks if an integer has more than 1 bit set */
 154
 155 #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
 156
 157 /* Approximation of the length of the decimal representation of this type. */
 158 #define decimal_length(x)       ((int)(sizeof(x) * 2.56 + 0.5) + 1)
 159
 160 #ifdef __MINGW64__
 161 #define _POSIX_C_SOURCE 1
 162 #elif defined(__sun__)
 163  /*
 164   * On Solaris, when _XOPEN_EXTENDED is set, its header file
 165   * forces the programs to be XPG4v2, defeating any _XOPEN_SOURCE
 166   * setting to say we are XPG5 or XPG6.  Also on Solaris,
 167   * XPG6 programs must be compiled with a c99 compiler, while
 168   * non XPG6 programs must be compiled with a pre-c99 compiler.
 169   */
 170 # if __STDC_VERSION__ - 0 >= 199901L
 171 # define _XOPEN_SOURCE 600
 172 # else
 173 # define _XOPEN_SOURCE 500
 174 # endif
 175 #elif !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__USLC__) && \
 176       !defined(_M_UNIX) && !defined(__sgi) && !defined(__DragonFly__) && \
 177       !defined(__TANDEM) && !defined(__QNX__) && !defined(__MirBSD__) && \
 178       !defined(__CYGWIN__)
 179 #define _XOPEN_SOURCE 600 /* glibc2 and AIX 5.3L need 500, OpenBSD needs 600 for S_ISLNK() */
 180 #define _XOPEN_SOURCE_EXTENDED 1 /* AIX 5.3L needs this */
 181 #endif
 182 #define _ALL_SOURCE 1
 183 #define _GNU_SOURCE 1
 184 #define _BSD_SOURCE 1
 185 #define _DEFAULT_SOURCE 1
 186 #define _NETBSD_SOURCE 1
 187 #define _SGI_SOURCE 1
 188
 189 #if defined(WIN32) && !defined(__CYGWIN__) /* Both MinGW and MSVC */
 190 # if !defined(_WIN32_WINNT)
 191 #  define _WIN32_WINNT 0x0600
 192 # endif
 193 #define WIN32_LEAN_AND_MEAN  /* stops windows.h including winsock.h */
 194 #include <winsock2.h>
 195 #ifndef NO_UNIX_SOCKETS
 196 #include <afunix.h>
 197 #endif
 198 #include <windows.h>
 199 #define GIT_WINDOWS_NATIVE
 200 #endif
 201
 202 #include <unistd.h>
 203 #include <stdio.h>
 204 #include <sys/stat.h>
 205 #include <fcntl.h>
 206 #include <stddef.h>
 207 #include <stdlib.h>
 208 #include <stdarg.h>
 209 #include <string.h>
 210 #ifdef HAVE_STRINGS_H
 211 #include <strings.h> /* for strcasecmp() */
 212 #endif
 213 #include <errno.h>
 214 #include <limits.h>
 215 #ifdef NEEDS_SYS_PARAM_H
 216 #include <sys/param.h>
 217 #endif
 218 #include <sys/types.h>
 219 #include <dirent.h>
 220 #include <sys/time.h>
 221 #include <time.h>
 222 #include <signal.h>
 223 #include <assert.h>
 224 #include <regex.h>
 225 #include <utime.h>
 226 #include <syslog.h>
 227 #if !defined(NO_POLL_H)
 228 #include <poll.h>
 229 #elif !defined(NO_SYS_POLL_H)
 230 #include <sys/poll.h>
 231 #else
 232 /* Pull the compat stuff */
 233 #include <poll.h>
 234 #endif
 235 #ifdef HAVE_BSD_SYSCTL
 236 #include <sys/sysctl.h>
 237 #endif
 238
 239 #if defined(__CYGWIN__)
 240 #include "compat/win32/path-utils.h"
 241 #endif
 242 #if defined(__MINGW32__)
 243 /* pull in Windows compatibility stuff */
 244 #include "compat/win32/path-utils.h"
 245 #include "compat/mingw.h"
 246 #elif defined(_MSC_VER)
 247 #include "compat/win32/path-utils.h"
 248 #include "compat/msvc.h"
 249 #else
 250 #include <sys/utsname.h>
 251 #include <sys/wait.h>
 252 #include <sys/resource.h>
 253 #include <sys/socket.h>
 254 #include <sys/ioctl.h>
 255 #include <termios.h>
 256 #ifndef NO_SYS_SELECT_H
 257 #include <sys/select.h>
 258 #endif
 259 #include <netinet/in.h>
 260 #include <netinet/tcp.h>
 261 #include <arpa/inet.h>
 262 #include <netdb.h>
 263 #include <pwd.h>
 264 #include <sys/un.h>
 265 #ifndef NO_INTTYPES_H
 266 #include <inttypes.h>
 267 #else
 268 #include <stdint.h>
 269 #endif
 270 #ifdef HAVE_ARC4RANDOM_LIBBSD
 271 #include <bsd/stdlib.h>
 272 #endif
 273 #ifdef HAVE_GETRANDOM
 274 #include <sys/random.h>
 275 #endif
 276 #ifdef NO_INTPTR_T
 277 /*
 278  * On I16LP32, ILP32 and LP64 "long" is the safe bet, however
 279  * on LLP86, IL33LLP64 and P64 it needs to be "long long",
 280  * while on IP16 and IP16L32 it is "int" (resp. "short")
 281  * Size needs to match (or exceed) 'sizeof(void *)'.
 282  * We can't take "long long" here as not everybody has it.
 283  */
 284 typedef long intptr_t;
 285 typedef unsigned long uintptr_t;
 286 #endif
 287 #undef _ALL_SOURCE /* AIX 5.3L defines a struct list with _ALL_SOURCE. */
 288 #include <grp.h>
 289 #define _ALL_SOURCE 1
 290 #endif
 291
 292 /* used on Mac OS X */
 293 #ifdef PRECOMPOSE_UNICODE
 294 #include "compat/precompose_utf8.h"
 295 #else
 296 static inline const char *precompose_argv_prefix(int argc, const char **argv, const char *prefix)
 297 {
 298         return prefix;
 299 }
 300 static inline const char *precompose_string_if_needed(const char *in)
 301 {
 302         return in;
 303 }
 304
 305 #define probe_utf8_pathname_composition()
 306 #endif
 307
 308 #ifdef MKDIR_WO_TRAILING_SLASH
 309 #define mkdir(a,b) compat_mkdir_wo_trailing_slash((a),(b))
 310 int compat_mkdir_wo_trailing_slash(const char*, mode_t);
 311 #endif
 312
 313 #ifdef NO_STRUCT_ITIMERVAL
 314 struct itimerval {
 315         struct timeval it_interval;
 316         struct timeval it_value;
 317 };
 318 #endif
 319
 320 #ifdef NO_SETITIMER
 321 static inline int setitimer(int which, const struct itimerval *value, struct itimerval *newvalue) {
 322         return 0; /* pretend success */
 323 }
 324 #endif
 325
 326 #ifndef NO_LIBGEN_H
 327 #include <libgen.h>
 328 #else
 329 #define basename gitbasename
 330 char *gitbasename(char *);
 331 #define dirname gitdirname
 332 char *gitdirname(char *);
 333 #endif
 334
 335 #ifndef NO_ICONV
 336 #include <iconv.h>
 337 #endif
 338
 339 #ifndef NO_OPENSSL
 340 #ifdef __APPLE__
 341 #define __AVAILABILITY_MACROS_USES_AVAILABILITY 0
 342 #include <AvailabilityMacros.h>
 343 #undef DEPRECATED_ATTRIBUTE
 344 #define DEPRECATED_ATTRIBUTE
 345 #undef __AVAILABILITY_MACROS_USES_AVAILABILITY
 346 #endif
 347 #include <openssl/ssl.h>
 348 #include <openssl/err.h>
 349 #endif
 350
 351 #ifdef HAVE_SYSINFO
 352 # include <sys/sysinfo.h>
 353 #endif
 354
 355 /* On most systems <netdb.h> would have given us this, but
 356  * not on some systems (e.g. z/OS).
 357  */
 358 #ifndef NI_MAXHOST
 359 #define NI_MAXHOST 1025
 360 #endif
 361
 362 #ifndef NI_MAXSERV
 363 #define NI_MAXSERV 32
 364 #endif
 365
 366 /* On most systems <limits.h> would have given us this, but
 367  * not on some systems (e.g. GNU/Hurd).
 368  */
 369 #ifndef PATH_MAX
 370 #define PATH_MAX 4096
 371 #endif
 372
 373 typedef uintmax_t timestamp_t;
 374 #define PRItime PRIuMAX
 375 #define parse_timestamp strtoumax
 376 #define TIME_MAX UINTMAX_MAX
 377 #define TIME_MIN 0
 378
 379 #ifndef PATH_SEP
 380 #define PATH_SEP ':'
 381 #endif
 382
 383 #ifdef HAVE_PATHS_H
 384 #include <paths.h>
 385 #endif
 386 #ifndef _PATH_DEFPATH
 387 #define _PATH_DEFPATH "/usr/local/bin:/usr/bin:/bin"
 388 #endif
 389
 390 #ifndef platform_core_config
 391 static inline int noop_core_config(const char *var, const char *value, void *cb)
 392 {
 393         return 0;
 394 }
 395 #define platform_core_config noop_core_config
 396 #endif
 397
 398 int lstat_cache_aware_rmdir(const char *path);
 399 #if !defined(__MINGW32__) && !defined(_MSC_VER)
 400 #define rmdir lstat_cache_aware_rmdir
 401 #endif
 402
 403 #ifndef has_dos_drive_prefix
 404 static inline int git_has_dos_drive_prefix(const char *path)
 405 {
 406         return 0;
 407 }
 408 #define has_dos_drive_prefix git_has_dos_drive_prefix
 409 #endif
 410
 411 #ifndef skip_dos_drive_prefix
 412 static inline int git_skip_dos_drive_prefix(char **path)
 413 {
 414         return 0;
 415 }
 416 #define skip_dos_drive_prefix git_skip_dos_drive_prefix
 417 #endif
 418
 419 #ifndef is_dir_sep
 420 static inline int git_is_dir_sep(int c)
 421 {
 422         return c == '/';
 423 }
 424 #define is_dir_sep git_is_dir_sep
 425 #endif
 426
 427 #ifndef offset_1st_component
 428 static inline int git_offset_1st_component(const char *path)
 429 {
 430         return is_dir_sep(path[0]);
 431 }
 432 #define offset_1st_component git_offset_1st_component
 433 #endif
 434
 435 #ifndef is_valid_path
 436 #define is_valid_path(path) 1
 437 #endif
 438
 439 #ifndef is_path_owned_by_current_user
 440 static inline int is_path_owned_by_current_uid(const char *path)
 441 {
 442         struct stat st;
 443         if (lstat(path, &st))
 444                 return 0;
 445         return st.st_uid == geteuid();
 446 }
 447
 448 #define is_path_owned_by_current_user is_path_owned_by_current_uid
 449 #endif
 450
 451 #ifndef find_last_dir_sep
 452 static inline char *git_find_last_dir_sep(const char *path)
 453 {
 454         return strrchr(path, '/');
 455 }
 456 #define find_last_dir_sep git_find_last_dir_sep
 457 #endif
 458
 459 #ifndef has_dir_sep
 460 static inline int git_has_dir_sep(const char *path)
 461 {
 462         return !!strchr(path, '/');
 463 }
 464 #define has_dir_sep(path) git_has_dir_sep(path)
 465 #endif
 466
 467 #ifndef query_user_email
 468 #define query_user_email() NULL
 469 #endif
 470
 471 #ifdef __TANDEM
 472 #include <floss.h(floss_execl,floss_execlp,floss_execv,floss_execvp)>
 473 #include <floss.h(floss_getpwuid)>
 474 #ifndef NSIG
 475 /*
 476  * NonStop NSE and NSX do not provide NSIG. SIGGUARDIAN(99) is the highest
 477  * known, by detective work using kill -l as a list is all signals
 478  * instead of signal.h where it should be.
 479  */
 480 # define NSIG 100
 481 #endif
 482 #endif
 483
 484 #if defined(__HP_cc) && (__HP_cc >= 61000)
 485 #define NORETURN __attribute__((noreturn))
 486 #define NORETURN_PTR
 487 #elif defined(__GNUC__) && !defined(NO_NORETURN)
 488 #define NORETURN __attribute__((__noreturn__))
 489 #define NORETURN_PTR __attribute__((__noreturn__))
 490 #elif defined(_MSC_VER)
 491 #define NORETURN __declspec(noreturn)
 492 #define NORETURN_PTR
 493 #else
 494 #define NORETURN
 495 #define NORETURN_PTR
 496 #ifndef __GNUC__
 497 #ifndef __attribute__
 498 #define __attribute__(x)
 499 #endif
 500 #endif
 501 #endif
 502
 503 /* The sentinel attribute is valid from gcc version 4.0 */
 504 #if defined(__GNUC__) && (__GNUC__ >= 4)
 505 #define LAST_ARG_MUST_BE_NULL __attribute__((sentinel))
 506 #else
 507 #define LAST_ARG_MUST_BE_NULL
 508 #endif
 509
 510 #define MAYBE_UNUSED __attribute__((__unused__))
 511
 512 #include "compat/bswap.h"
 513
 514 #include "wildmatch.h"
 515
 516 struct strbuf;
 517
 518 /* General helper functions */
 519 NORETURN void usage(const char *err);
 520 NORETURN void usagef(const char *err, ...) __attribute__((format (printf, 1, 2)));
 521 NORETURN void die(const char *err, ...) __attribute__((format (printf, 1, 2)));
 522 NORETURN void die_errno(const char *err, ...) __attribute__((format (printf, 1, 2)));
 523 int die_message(const char *err, ...) __attribute__((format (printf, 1, 2)));
 524 int die_message_errno(const char *err, ...) __attribute__((format (printf, 1, 2)));
 525 int error(const char *err, ...) __attribute__((format (printf, 1, 2)));
 526 int error_errno(const char *err, ...) __attribute__((format (printf, 1, 2)));
 527 void warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
 528 void warning_errno(const char *err, ...) __attribute__((format (printf, 1, 2)));
 529
 530 #ifndef NO_OPENSSL
 531 #ifdef APPLE_COMMON_CRYPTO
 532 #include "compat/apple-common-crypto.h"
 533 #else
 534 #include <openssl/evp.h>
 535 #include <openssl/hmac.h>
 536 #endif /* APPLE_COMMON_CRYPTO */
 537 #include <openssl/x509v3.h>
 538 #endif /* NO_OPENSSL */
 539
 540 #ifdef HAVE_OPENSSL_CSPRNG
 541 #include <openssl/rand.h>
 542 #endif
 543
 544 /*
 545  * Let callers be aware of the constant return value; this can help
 546  * gcc with -Wuninitialized analysis. We restrict this trick to gcc, though,
 547  * because other compilers may be confused by this.
 548  */
 549 #if defined(__GNUC__)
 550 static inline int const_error(void)
 551 {
 552         return -1;
 553 }
 554 #define error(...) (error(__VA_ARGS__), const_error())
 555 #define error_errno(...) (error_errno(__VA_ARGS__), const_error())
 556 #endif
 557
 558 typedef void (*report_fn)(const char *, va_list params);
 559
 560 void set_die_routine(NORETURN_PTR report_fn routine);
 561 report_fn get_die_message_routine(void);
 562 void set_error_routine(report_fn routine);
 563 report_fn get_error_routine(void);
 564 void set_warn_routine(report_fn routine);
 565 report_fn get_warn_routine(void);
 566 void set_die_is_recursing_routine(int (*routine)(void));
 567
 568 int starts_with(const char *str, const char *prefix);
 569 int istarts_with(const char *str, const char *prefix);
 570
 571 /*
 572  * If the string "str" begins with the string found in "prefix", return 1.
 573  * The "out" parameter is set to "str + strlen(prefix)" (i.e., to the point in
 574  * the string right after the prefix).
 575  *
 576  * Otherwise, return 0 and leave "out" untouched.
 577  *
 578  * Examples:
 579  *
 580  *   [extract branch name, fail if not a branch]
 581  *   if (!skip_prefix(ref, "refs/heads/", &branch)
 582  *      return -1;
 583  *
 584  *   [skip prefix if present, otherwise use whole string]
 585  *   skip_prefix(name, "refs/heads/", &name);
 586  */
 587 static inline int skip_prefix(const char *str, const char *prefix,
 588                               const char **out)
 589 {
 590         do {
 591                 if (!*prefix) {
 592                         *out = str;
 593                         return 1;
 594                 }
 595         } while (*str++ == *prefix++);
 596         return 0;
 597 }
 598
 599 /*
 600  * If the string "str" is the same as the string in "prefix", then the "arg"
 601  * parameter is set to the "def" parameter and 1 is returned.
 602  * If the string "str" begins with the string found in "prefix" and then a
 603  * "=" sign, then the "arg" parameter is set to "str + strlen(prefix) + 1"
 604  * (i.e., to the point in the string right after the prefix and the "=" sign),
 605  * and 1 is returned.
 606  *
 607  * Otherwise, return 0 and leave "arg" untouched.
 608  *
 609  * When we accept both a "--key" and a "--key=<val>" option, this function
 610  * can be used instead of !strcmp(arg, "--key") and then
 611  * skip_prefix(arg, "--key=", &arg) to parse such an option.
 612  */
 613 int skip_to_optional_arg_default(const char *str, const char *prefix,
 614                                  const char **arg, const char *def);
 615
 616 static inline int skip_to_optional_arg(const char *str, const char *prefix,
 617                                        const char **arg)
 618 {
 619         return skip_to_optional_arg_default(str, prefix, arg, "");
 620 }
 621
 622 /*
 623  * Like skip_prefix, but promises never to read past "len" bytes of the input
 624  * buffer, and returns the remaining number of bytes in "out" via "outlen".
 625  */
 626 static inline int skip_prefix_mem(const char *buf, size_t len,
 627                                   const char *prefix,
 628                                   const char **out, size_t *outlen)
 629 {
 630         size_t prefix_len = strlen(prefix);
 631         if (prefix_len <= len && !memcmp(buf, prefix, prefix_len)) {
 632                 *out = buf + prefix_len;
 633                 *outlen = len - prefix_len;
 634                 return 1;
 635         }
 636         return 0;
 637 }
 638
 639 /*
 640  * If buf ends with suffix, return 1 and subtract the length of the suffix
 641  * from *len. Otherwise, return 0 and leave *len untouched.
 642  */
 643 static inline int strip_suffix_mem(const char *buf, size_t *len,
 644                                    const char *suffix)
 645 {
 646         size_t suflen = strlen(suffix);
 647         if (*len < suflen || memcmp(buf + (*len - suflen), suffix, suflen))
 648                 return 0;
 649         *len -= suflen;
 650         return 1;
 651 }
 652
 653 /*
 654  * If str ends with suffix, return 1 and set *len to the size of the string
 655  * without the suffix. Otherwise, return 0 and set *len to the size of the
 656  * string.
 657  *
 658  * Note that we do _not_ NUL-terminate str to the new length.
 659  */
 660 static inline int strip_suffix(const char *str, const char *suffix, size_t *len)
 661 {
 662         *len = strlen(str);
 663         return strip_suffix_mem(str, len, suffix);
 664 }
 665
 666 static inline int ends_with(const char *str, const char *suffix)
 667 {
 668         size_t len;
 669         return strip_suffix(str, suffix, &len);
 670 }
 671
 672 #define SWAP(a, b) do {                                         \
 673         void *_swap_a_ptr = &(a);                               \
 674         void *_swap_b_ptr = &(b);                               \
 675         unsigned char _swap_buffer[sizeof(a)];                  \
 676         memcpy(_swap_buffer, _swap_a_ptr, sizeof(a));           \
 677         memcpy(_swap_a_ptr, _swap_b_ptr, sizeof(a) +            \
 678                BUILD_ASSERT_OR_ZERO(sizeof(a) == sizeof(b)));   \
 679         memcpy(_swap_b_ptr, _swap_buffer, sizeof(a));           \
 680 } while (0)
 681
 682 #if defined(NO_MMAP) || defined(USE_WIN32_MMAP)
 683
 684 #ifndef PROT_READ
 685 #define PROT_READ 1
 686 #define PROT_WRITE 2
 687 #define MAP_PRIVATE 1
 688 #endif
 689
 690 #define mmap git_mmap
 691 #define munmap git_munmap
 692 void *git_mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);
 693 int git_munmap(void *start, size_t length);
 694
 695 #else /* NO_MMAP || USE_WIN32_MMAP */
 696
 697 #include <sys/mman.h>
 698
 699 #endif /* NO_MMAP || USE_WIN32_MMAP */
 700
 701 #ifdef NO_MMAP
 702
 703 /* This value must be multiple of (pagesize * 2) */
 704 #define DEFAULT_PACKED_GIT_WINDOW_SIZE (1 * 1024 * 1024)
 705
 706 #else /* NO_MMAP */
 707
 708 /* This value must be multiple of (pagesize * 2) */
 709 #define DEFAULT_PACKED_GIT_WINDOW_SIZE \
 710         (sizeof(void*) >= 8 \
 711                 ?  1 * 1024 * 1024 * 1024 \
 712                 : 32 * 1024 * 1024)
 713
 714 #endif /* NO_MMAP */
 715
 716 #ifndef MAP_FAILED
 717 #define MAP_FAILED ((void *)-1)
 718 #endif
 719
 720 #ifdef NO_ST_BLOCKS_IN_STRUCT_STAT
 721 #define on_disk_bytes(st) ((st).st_size)
 722 #else
 723 #define on_disk_bytes(st) ((st).st_blocks * 512)
 724 #endif
 725
 726 #ifdef NEEDS_MODE_TRANSLATION
 727 #undef S_IFMT
 728 #undef S_IFREG
 729 #undef S_IFDIR
 730 #undef S_IFLNK
 731 #undef S_IFBLK
 732 #undef S_IFCHR
 733 #undef S_IFIFO
 734 #undef S_IFSOCK
 735 #define S_IFMT   0170000
 736 #define S_IFREG  0100000
 737 #define S_IFDIR  0040000
 738 #define S_IFLNK  0120000
 739 #define S_IFBLK  0060000
 740 #define S_IFCHR  0020000
 741 #define S_IFIFO  0010000
 742 #define S_IFSOCK 0140000
 743 #ifdef stat
 744 #undef stat
 745 #endif
 746 #define stat(path, buf) git_stat(path, buf)
 747 int git_stat(const char *, struct stat *);
 748 #ifdef fstat
 749 #undef fstat
 750 #endif
 751 #define fstat(fd, buf) git_fstat(fd, buf)
 752 int git_fstat(int, struct stat *);
 753 #ifdef lstat
 754 #undef lstat
 755 #endif
 756 #define lstat(path, buf) git_lstat(path, buf)
 757 int git_lstat(const char *, struct stat *);
 758 #endif
 759
 760 #define DEFAULT_PACKED_GIT_LIMIT \
 761         ((1024L * 1024L) * (size_t)(sizeof(void*) >= 8 ? (32 * 1024L * 1024L) : 256))
 762
 763 #ifdef NO_PREAD
 764 #define pread git_pread
 765 ssize_t git_pread(int fd, void *buf, size_t count, off_t offset);
 766 #endif
 767 /*
 768  * Forward decl that will remind us if its twin in cache.h changes.
 769  * This function is used in compat/pread.c.  But we can't include
 770  * cache.h there.
 771  */
 772 ssize_t read_in_full(int fd, void *buf, size_t count);
 773
 774 #ifdef NO_SETENV
 775 #define setenv gitsetenv
 776 int gitsetenv(const char *, const char *, int);
 777 #endif
 778
 779 #ifdef NO_MKDTEMP
 780 #define mkdtemp gitmkdtemp
 781 char *gitmkdtemp(char *);
 782 #endif
 783
 784 #ifdef NO_UNSETENV
 785 #define unsetenv gitunsetenv
 786 int gitunsetenv(const char *);
 787 #endif
 788
 789 #ifdef NO_STRCASESTR
 790 #define strcasestr gitstrcasestr
 791 char *gitstrcasestr(const char *haystack, const char *needle);
 792 #endif
 793
 794 #ifdef NO_STRLCPY
 795 #define strlcpy gitstrlcpy
 796 size_t gitstrlcpy(char *, const char *, size_t);
 797 #endif
 798
 799 #ifdef NO_STRTOUMAX
 800 #define strtoumax gitstrtoumax
 801 uintmax_t gitstrtoumax(const char *, char **, int);
 802 #define strtoimax gitstrtoimax
 803 intmax_t gitstrtoimax(const char *, char **, int);
 804 #endif
 805
 806 #ifdef NO_HSTRERROR
 807 #define hstrerror githstrerror
 808 const char *githstrerror(int herror);
 809 #endif
 810
 811 #ifdef NO_MEMMEM
 812 #define memmem gitmemmem
 813 void *gitmemmem(const void *haystack, size_t haystacklen,
 814                 const void *needle, size_t needlelen);
 815 #endif
 816
 817 #ifdef OVERRIDE_STRDUP
 818 #ifdef strdup
 819 #undef strdup
 820 #endif
 821 #define strdup gitstrdup
 822 char *gitstrdup(const char *s);
 823 #endif
 824
 825 #ifdef NO_GETPAGESIZE
 826 #define getpagesize() sysconf(_SC_PAGESIZE)
 827 #endif
 828
 829 #ifndef O_CLOEXEC
 830 #define O_CLOEXEC 0
 831 #endif
 832
 833 #ifdef FREAD_READS_DIRECTORIES
 834 # if !defined(SUPPRESS_FOPEN_REDEFINITION)
 835 #  ifdef fopen
 836 #   undef fopen
 837 #  endif
 838 #  define fopen(a,b) git_fopen(a,b)
 839 # endif
 840 FILE *git_fopen(const char*, const char*);
 841 #endif
 842
 843 #ifdef SNPRINTF_RETURNS_BOGUS
 844 #ifdef snprintf
 845 #undef snprintf
 846 #endif
 847 #define snprintf git_snprintf
 848 int git_snprintf(char *str, size_t maxsize,
 849                  const char *format, ...);
 850 #ifdef vsnprintf
 851 #undef vsnprintf
 852 #endif
 853 #define vsnprintf git_vsnprintf
 854 int git_vsnprintf(char *str, size_t maxsize,
 855                   const char *format, va_list ap);
 856 #endif
 857
 858 #ifdef OPEN_RETURNS_EINTR
 859 #undef open
 860 #define open git_open_with_retry
 861 int git_open_with_retry(const char *path, int flag, ...);
 862 #endif
 863
 864 #ifdef __GLIBC_PREREQ
 865 #if __GLIBC_PREREQ(2, 1)
 866 #define HAVE_STRCHRNUL
 867 #endif
 868 #endif
 869
 870 #ifndef HAVE_STRCHRNUL
 871 #define strchrnul gitstrchrnul
 872 static inline char *gitstrchrnul(const char *s, int c)
 873 {
 874         while (*s && *s != c)
 875                 s++;
 876         return (char *)s;
 877 }
 878 #endif
 879
 880 #ifdef NO_INET_PTON
 881 int inet_pton(int af, const char *src, void *dst);
 882 #endif
 883
 884 #ifdef NO_INET_NTOP
 885 const char *inet_ntop(int af, const void *src, char *dst, size_t size);
 886 #endif
 887
 888 #ifdef NO_PTHREADS
 889 #define atexit git_atexit
 890 int git_atexit(void (*handler)(void));
 891 #endif
 892
 893 static inline size_t st_add(size_t a, size_t b)
 894 {
 895         if (unsigned_add_overflows(a, b))
 896                 die("size_t overflow: %"PRIuMAX" + %"PRIuMAX,
 897                     (uintmax_t)a, (uintmax_t)b);
 898         return a + b;
 899 }
 900 #define st_add3(a,b,c)   st_add(st_add((a),(b)),(c))
 901 #define st_add4(a,b,c,d) st_add(st_add3((a),(b),(c)),(d))
 902
 903 static inline size_t st_mult(size_t a, size_t b)
 904 {
 905         if (unsigned_mult_overflows(a, b))
 906                 die("size_t overflow: %"PRIuMAX" * %"PRIuMAX,
 907                     (uintmax_t)a, (uintmax_t)b);
 908         return a * b;
 909 }
 910
 911 static inline size_t st_sub(size_t a, size_t b)
 912 {
 913         if (a < b)
 914                 die("size_t underflow: %"PRIuMAX" - %"PRIuMAX,
 915                     (uintmax_t)a, (uintmax_t)b);
 916         return a - b;
 917 }
 918
 919 static inline size_t st_left_shift(size_t a, unsigned shift)
 920 {
 921         if (unsigned_left_shift_overflows(a, shift))
 922                 die("size_t overflow: %"PRIuMAX" << %u",
 923                     (uintmax_t)a, shift);
 924         return a << shift;
 925 }
 926
 927 static inline unsigned long cast_size_t_to_ulong(size_t a)
 928 {
 929         if (a != (unsigned long)a)
 930                 die("object too large to read on this platform: %"
 931                     PRIuMAX" is cut off to %lu",
 932                     (uintmax_t)a, (unsigned long)a);
 933         return (unsigned long)a;
 934 }
 935
 936 #ifdef HAVE_ALLOCA_H
 937 # include <alloca.h>
 938 # define xalloca(size)      (alloca(size))
 939 # define xalloca_free(p)    do {} while (0)
 940 #else
 941 # define xalloca(size)      (xmalloc(size))
 942 # define xalloca_free(p)    (free(p))
 943 #endif
 944 char *xstrdup(const char *str);
 945 void *xmalloc(size_t size);
 946 void *xmallocz(size_t size);
 947 void *xmallocz_gently(size_t size);
 948 void *xmemdupz(const void *data, size_t len);
 949 char *xstrndup(const char *str, size_t len);
 950 void *xrealloc(void *ptr, size_t size);
 951 void *xcalloc(size_t nmemb, size_t size);
 952 void xsetenv(const char *name, const char *value, int overwrite);
 953 void *xmmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);
 954 const char *mmap_os_err(void);
 955 void *xmmap_gently(void *start, size_t length, int prot, int flags, int fd, off_t offset);
 956 int xopen(const char *path, int flags, ...);
 957 ssize_t xread(int fd, void *buf, size_t len);
 958 ssize_t xwrite(int fd, const void *buf, size_t len);
 959 ssize_t xpread(int fd, void *buf, size_t len, off_t offset);
 960 int xdup(int fd);
 961 FILE *xfopen(const char *path, const char *mode);
 962 FILE *xfdopen(int fd, const char *mode);
 963 int xmkstemp(char *temp_filename);
 964 int xmkstemp_mode(char *temp_filename, int mode);
 965 char *xgetcwd(void);
 966 FILE *fopen_for_writing(const char *path);
 967 FILE *fopen_or_warn(const char *path, const char *mode);
 968
 969 /*
 970  * Like strncmp, but only return zero if s is NUL-terminated and exactly len
 971  * characters long.  If it is not, consider it greater than t.
 972  */
 973 int xstrncmpz(const char *s, const char *t, size_t len);
 974
 975 /*
 976  * FREE_AND_NULL(ptr) is like free(ptr) followed by ptr = NULL. Note
 977  * that ptr is used twice, so don't pass e.g. ptr++.
 978  */
 979 #define FREE_AND_NULL(p) do { free(p); (p) = NULL; } while (0)
 980
 981 #define ALLOC_ARRAY(x, alloc) (x) = xmalloc(st_mult(sizeof(*(x)), (alloc)))
 982 #define CALLOC_ARRAY(x, alloc) (x) = xcalloc((alloc), sizeof(*(x)))
 983 #define REALLOC_ARRAY(x, alloc) (x) = xrealloc((x), st_mult(sizeof(*(x)), (alloc)))
 984
 985 #define COPY_ARRAY(dst, src, n) copy_array((dst), (src), (n), sizeof(*(dst)) + \
 986         BUILD_ASSERT_OR_ZERO(sizeof(*(dst)) == sizeof(*(src))))
 987 static inline void copy_array(void *dst, const void *src, size_t n, size_t size)
 988 {
 989         if (n)
 990                 memcpy(dst, src, st_mult(size, n));
 991 }
 992
 993 #define MOVE_ARRAY(dst, src, n) move_array((dst), (src), (n), sizeof(*(dst)) + \
 994         BUILD_ASSERT_OR_ZERO(sizeof(*(dst)) == sizeof(*(src))))
 995 static inline void move_array(void *dst, const void *src, size_t n, size_t size)
 996 {
 997         if (n)
 998                 memmove(dst, src, st_mult(size, n));
 999 }
1000
1001 /*
1002  * These functions help you allocate structs with flex arrays, and copy
1003  * the data directly into the array. For example, if you had:
1004  *
1005  *   struct foo {
1006  *     int bar;
1007  *     char name[FLEX_ARRAY];
1008  *   };
1009  *
1010  * you can do:
1011  *
1012  *   struct foo *f;
1013  *   FLEX_ALLOC_MEM(f, name, src, len);
1014  *
1015  * to allocate a "foo" with the contents of "src" in the "name" field.
1016  * The resulting struct is automatically zero'd, and the flex-array field
1017  * is NUL-terminated (whether the incoming src buffer was or not).
1018  *
1019  * The FLEXPTR_* variants operate on structs that don't use flex-arrays,
1020  * but do want to store a pointer to some extra data in the same allocated
1021  * block. For example, if you have:
1022  *
1023  *   struct foo {
1024  *     char *name;
1025  *     int bar;
1026  *   };
1027  *
1028  * you can do:
1029  *
1030  *   struct foo *f;
1031  *   FLEXPTR_ALLOC_STR(f, name, src);
1032  *
1033  * and "name" will point to a block of memory after the struct, which will be
1034  * freed along with the struct (but the pointer can be repointed anywhere).
1035  *
1036  * The *_STR variants accept a string parameter rather than a ptr/len
1037  * combination.
1038  *
1039  * Note that these macros will evaluate the first parameter multiple
1040  * times, and it must be assignable as an lvalue.
1041  */
1042 #define FLEX_ALLOC_MEM(x, flexname, buf, len) do { \
1043         size_t flex_array_len_ = (len); \
1044         (x) = xcalloc(1, st_add3(sizeof(*(x)), flex_array_len_, 1)); \
1045         memcpy((void *)(x)->flexname, (buf), flex_array_len_); \
1046 } while (0)
1047 #define FLEXPTR_ALLOC_MEM(x, ptrname, buf, len) do { \
1048         size_t flex_array_len_ = (len); \
1049         (x) = xcalloc(1, st_add3(sizeof(*(x)), flex_array_len_, 1)); \
1050         memcpy((x) + 1, (buf), flex_array_len_); \
1051         (x)->ptrname = (void *)((x)+1); \
1052 } while(0)
1053 #define FLEX_ALLOC_STR(x, flexname, str) \
1054         FLEX_ALLOC_MEM((x), flexname, (str), strlen(str))
1055 #define FLEXPTR_ALLOC_STR(x, ptrname, str) \
1056         FLEXPTR_ALLOC_MEM((x), ptrname, (str), strlen(str))
1057
1058 static inline char *xstrdup_or_null(const char *str)
1059 {
1060         return str ? xstrdup(str) : NULL;
1061 }
1062
1063 static inline size_t xsize_t(off_t len)
1064 {
1065         if (len < 0 || (uintmax_t) len > SIZE_MAX)
1066                 die("Cannot handle files this big");
1067         return (size_t) len;
1068 }
1069
1070 __attribute__((format (printf, 3, 4)))
1071 int xsnprintf(char *dst, size_t max, const char *fmt, ...);
1072
1073 #ifndef HOST_NAME_MAX
1074 #define HOST_NAME_MAX 256
1075 #endif
1076
1077 int xgethostname(char *buf, size_t len);
1078
1079 /* in ctype.c, for kwset users */
1080 extern const unsigned char tolower_trans_tbl[256];
1081
1082 /* Sane ctype - no locale, and works with signed chars */
1083 #undef isascii
1084 #undef isspace
1085 #undef isdigit
1086 #undef isalpha
1087 #undef isalnum
1088 #undef isprint
1089 #undef islower
1090 #undef isupper
1091 #undef tolower
1092 #undef toupper
1093 #undef iscntrl
1094 #undef ispunct
1095 #undef isxdigit
1096
1097 extern const unsigned char sane_ctype[256];
1098 #define GIT_SPACE 0x01
1099 #define GIT_DIGIT 0x02
1100 #define GIT_ALPHA 0x04
1101 #define GIT_GLOB_SPECIAL 0x08
1102 #define GIT_REGEX_SPECIAL 0x10
1103 #define GIT_PATHSPEC_MAGIC 0x20
1104 #define GIT_CNTRL 0x40
1105 #define GIT_PUNCT 0x80
1106 #define sane_istest(x,mask) ((sane_ctype[(unsigned char)(x)] & (mask)) != 0)
1107 #define isascii(x) (((x) & ~0x7f) == 0)
1108 #define isspace(x) sane_istest(x,GIT_SPACE)
1109 #define isdigit(x) sane_istest(x,GIT_DIGIT)
1110 #define isalpha(x) sane_istest(x,GIT_ALPHA)
1111 #define isalnum(x) sane_istest(x,GIT_ALPHA | GIT_DIGIT)
1112 #define isprint(x) ((x) >= 0x20 && (x) <= 0x7e)
1113 #define islower(x) sane_iscase(x, 1)
1114 #define isupper(x) sane_iscase(x, 0)
1115 #define is_glob_special(x) sane_istest(x,GIT_GLOB_SPECIAL)
1116 #define is_regex_special(x) sane_istest(x,GIT_GLOB_SPECIAL | GIT_REGEX_SPECIAL)
1117 #define iscntrl(x) (sane_istest(x,GIT_CNTRL))
1118 #define ispunct(x) sane_istest(x, GIT_PUNCT | GIT_REGEX_SPECIAL | \
1119                 GIT_GLOB_SPECIAL | GIT_PATHSPEC_MAGIC)
1120 #define isxdigit(x) (hexval_table[(unsigned char)(x)] != -1)
1121 #define tolower(x) sane_case((unsigned char)(x), 0x20)
1122 #define toupper(x) sane_case((unsigned char)(x), 0)
1123 #define is_pathspec_magic(x) sane_istest(x,GIT_PATHSPEC_MAGIC)
1124
1125 static inline int sane_case(int x, int high)
1126 {
1127         if (sane_istest(x, GIT_ALPHA))
1128                 x = (x & ~0x20) | high;
1129         return x;
1130 }
1131
1132 static inline int sane_iscase(int x, int is_lower)
1133 {
1134         if (!sane_istest(x, GIT_ALPHA))
1135                 return 0;
1136
1137         if (is_lower)
1138                 return (x & 0x20) != 0;
1139         else
1140                 return (x & 0x20) == 0;
1141 }
1142
1143 /*
1144  * Like skip_prefix, but compare case-insensitively. Note that the comparison
1145  * is done via tolower(), so it is strictly ASCII (no multi-byte characters or
1146  * locale-specific conversions).
1147  */
1148 static inline int skip_iprefix(const char *str, const char *prefix,
1149                                const char **out)
1150 {
1151         do {
1152                 if (!*prefix) {
1153                         *out = str;
1154                         return 1;
1155                 }
1156         } while (tolower(*str++) == tolower(*prefix++));
1157         return 0;
1158 }
1159
1160 static inline int strtoul_ui(char const *s, int base, unsigned int *result)
1161 {
1162         unsigned long ul;
1163         char *p;
1164
1165         errno = 0;
1166         /* negative values would be accepted by strtoul */
1167         if (strchr(s, '-'))
1168                 return -1;
1169         ul = strtoul(s, &p, base);
1170         if (errno || *p || p == s || (unsigned int) ul != ul)
1171                 return -1;
1172         *result = ul;
1173         return 0;
1174 }
1175
1176 static inline int strtol_i(char const *s, int base, int *result)
1177 {
1178         long ul;
1179         char *p;
1180
1181         errno = 0;
1182         ul = strtol(s, &p, base);
1183         if (errno || *p || p == s || (int) ul != ul)
1184                 return -1;
1185         *result = ul;
1186         return 0;
1187 }
1188
1189 void git_stable_qsort(void *base, size_t nmemb, size_t size,
1190                       int(*compar)(const void *, const void *));
1191 #ifdef INTERNAL_QSORT
1192 #define qsort git_stable_qsort
1193 #endif
1194
1195 #define QSORT(base, n, compar) sane_qsort((base), (n), sizeof(*(base)), compar)
1196 static inline void sane_qsort(void *base, size_t nmemb, size_t size,
1197                               int(*compar)(const void *, const void *))
1198 {
1199         if (nmemb > 1)
1200                 qsort(base, nmemb, size, compar);
1201 }
1202
1203 #define STABLE_QSORT(base, n, compar) \
1204         git_stable_qsort((base), (n), sizeof(*(base)), compar)
1205
1206 #ifndef HAVE_ISO_QSORT_S
1207 int git_qsort_s(void *base, size_t nmemb, size_t size,
1208                 int (*compar)(const void *, const void *, void *), void *ctx);
1209 #define qsort_s git_qsort_s
1210 #endif
1211
1212 #define QSORT_S(base, n, compar, ctx) do {                      \
1213         if (qsort_s((base), (n), sizeof(*(base)), compar, ctx)) \
1214                 BUG("qsort_s() failed");                        \
1215 } while (0)
1216
1217 #ifndef REG_STARTEND
1218 #error "Git requires REG_STARTEND support. Compile with NO_REGEX=NeedsStartEnd"
1219 #endif
1220
1221 static inline int regexec_buf(const regex_t *preg, const char *buf, size_t size,
1222                               size_t nmatch, regmatch_t pmatch[], int eflags)
1223 {
1224         assert(nmatch > 0 && pmatch);
1225         pmatch[0].rm_so = 0;
1226         pmatch[0].rm_eo = size;
1227         return regexec(preg, buf, nmatch, pmatch, eflags | REG_STARTEND);
1228 }
1229
1230 #ifndef DIR_HAS_BSD_GROUP_SEMANTICS
1231 # define FORCE_DIR_SET_GID S_ISGID
1232 #else
1233 # define FORCE_DIR_SET_GID 0
1234 #endif
1235
1236 #ifdef NO_NSEC
1237 #undef USE_NSEC
1238 #define ST_CTIME_NSEC(st) 0
1239 #define ST_MTIME_NSEC(st) 0
1240 #else
1241 #ifdef USE_ST_TIMESPEC
1242 #define ST_CTIME_NSEC(st) ((unsigned int)((st).st_ctimespec.tv_nsec))
1243 #define ST_MTIME_NSEC(st) ((unsigned int)((st).st_mtimespec.tv_nsec))
1244 #else
1245 #define ST_CTIME_NSEC(st) ((unsigned int)((st).st_ctim.tv_nsec))
1246 #define ST_MTIME_NSEC(st) ((unsigned int)((st).st_mtim.tv_nsec))
1247 #endif
1248 #endif
1249
1250 #ifdef UNRELIABLE_FSTAT
1251 #define fstat_is_reliable() 0
1252 #else
1253 #define fstat_is_reliable() 1
1254 #endif
1255
1256 #ifndef va_copy
1257 /*
1258  * Since an obvious implementation of va_list would be to make it a
1259  * pointer into the stack frame, a simple assignment will work on
1260  * many systems.  But let's try to be more portable.
1261  */
1262 #ifdef __va_copy
1263 #define va_copy(dst, src) __va_copy(dst, src)
1264 #else
1265 #define va_copy(dst, src) ((dst) = (src))
1266 #endif
1267 #endif
1268
1269 /* usage.c: only to be used for testing BUG() implementation (see test-tool) */
1270 extern int BUG_exit_code;
1271
1272 __attribute__((format (printf, 3, 4))) NORETURN
1273 void BUG_fl(const char *file, int line, const char *fmt, ...);
1274 #define BUG(...) BUG_fl(__FILE__, __LINE__, __VA_ARGS__)
1275
1276 #ifdef __APPLE__
1277 #define FSYNC_METHOD_DEFAULT FSYNC_METHOD_WRITEOUT_ONLY
1278 #else
1279 #define FSYNC_METHOD_DEFAULT FSYNC_METHOD_FSYNC
1280 #endif
1281
1282 enum fsync_action {
1283         FSYNC_WRITEOUT_ONLY,
1284         FSYNC_HARDWARE_FLUSH
1285 };
1286
1287 /*
1288  * Issues an fsync against the specified file according to the specified mode.
1289  *
1290  * FSYNC_WRITEOUT_ONLY attempts to use interfaces available on some operating
1291  * systems to flush the OS cache without issuing a flush command to the storage
1292  * controller. If those interfaces are unavailable, the function fails with
1293  * ENOSYS.
1294  *
1295  * FSYNC_HARDWARE_FLUSH does an OS writeout and hardware flush to ensure that
1296  * changes are durable. It is not expected to fail.
1297  */
1298 int git_fsync(int fd, enum fsync_action action);
1299
1300 /*
1301  * Writes out trace statistics for fsync using the trace2 API.
1302  */
1303 void trace_git_fsync_stats(void);
1304
1305 /*
1306  * Preserves errno, prints a message, but gives no warning for ENOENT.
1307  * Returns 0 on success, which includes trying to unlink an object that does
1308  * not exist.
1309  */
1310 int unlink_or_warn(const char *path);
1311  /*
1312   * Tries to unlink file.  Returns 0 if unlink succeeded
1313   * or the file already didn't exist.  Returns -1 and
1314   * appends a message to err suitable for
1315   * 'error("%s", err->buf)' on error.
1316   */
1317 int unlink_or_msg(const char *file, struct strbuf *err);
1318 /*
1319  * Preserves errno, prints a message, but gives no warning for ENOENT.
1320  * Returns 0 on success, which includes trying to remove a directory that does
1321  * not exist.
1322  */
1323 int rmdir_or_warn(const char *path);
1324 /*
1325  * Calls the correct function out of {unlink,rmdir}_or_warn based on
1326  * the supplied file mode.
1327  */
1328 int remove_or_warn(unsigned int mode, const char *path);
1329
1330 /*
1331  * Call access(2), but warn for any error except "missing file"
1332  * (ENOENT or ENOTDIR).
1333  */
1334 #define ACCESS_EACCES_OK (1U << 0)
1335 int access_or_warn(const char *path, int mode, unsigned flag);
1336 int access_or_die(const char *path, int mode, unsigned flag);
1337
1338 /* Warn on an inaccessible file if errno indicates this is an error */
1339 int warn_on_fopen_errors(const char *path);
1340
1341 /*
1342  * Open with O_NOFOLLOW, or equivalent. Note that the fallback equivalent
1343  * may be racy. Do not use this as protection against an attacker who can
1344  * simultaneously create paths.
1345  */
1346 int open_nofollow(const char *path, int flags);
1347
1348 #ifndef SHELL_PATH
1349 # define SHELL_PATH "/bin/sh"
1350 #endif
1351
1352 #ifndef _POSIX_THREAD_SAFE_FUNCTIONS
1353 static inline void flockfile(FILE *fh)
1354 {
1355         ; /* nothing */
1356 }
1357 static inline void funlockfile(FILE *fh)
1358 {
1359         ; /* nothing */
1360 }
1361 #define getc_unlocked(fh) getc(fh)
1362 #endif
1363
1364 #ifdef FILENO_IS_A_MACRO
1365 int git_fileno(FILE *stream);
1366 # ifndef COMPAT_CODE_FILENO
1367 #  undef fileno
1368 #  define fileno(p) git_fileno(p)
1369 # endif
1370 #endif
1371
1372 #ifdef NEED_ACCESS_ROOT_HANDLER
1373 int git_access(const char *path, int mode);
1374 # ifndef COMPAT_CODE_ACCESS
1375 #  ifdef access
1376 #  undef access
1377 #  endif
1378 #  define access(path, mode) git_access(path, mode)
1379 # endif
1380 #endif
1381
1382 /*
1383  * Our code often opens a path to an optional file, to work on its
1384  * contents when we can successfully open it.  We can ignore a failure
1385  * to open if such an optional file does not exist, but we do want to
1386  * report a failure in opening for other reasons (e.g. we got an I/O
1387  * error, or the file is there, but we lack the permission to open).
1388  *
1389  * Call this function after seeing an error from open() or fopen() to
1390  * see if the errno indicates a missing file that we can safely ignore.
1391  */
1392 static inline int is_missing_file_error(int errno_)
1393 {
1394         return (errno_ == ENOENT || errno_ == ENOTDIR);
1395 }
1396
1397 int cmd_main(int, const char **);
1398
1399 /*
1400  * Intercept all calls to exit() and route them to trace2 to
1401  * optionally emit a message before calling the real exit().
1402  */
1403 int trace2_cmd_exit_fl(const char *file, int line, int code);
1404 #define exit(code) exit(trace2_cmd_exit_fl(__FILE__, __LINE__, (code)))
1405
1406 /*
1407  * You can mark a stack variable with UNLEAK(var) to avoid it being
1408  * reported as a leak by tools like LSAN or valgrind. The argument
1409  * should generally be the variable itself (not its address and not what
1410  * it points to). It's safe to use this on pointers which may already
1411  * have been freed, or on pointers which may still be in use.
1412  *
1413  * Use this _only_ for a variable that leaks by going out of scope at
1414  * program exit (so only from cmd_* functions or their direct helpers).
1415  * Normal functions, especially those which may be called multiple
1416  * times, should actually free their memory. This is only meant as
1417  * an annotation, and does nothing in non-leak-checking builds.
1418  */
1419 #ifdef SUPPRESS_ANNOTATED_LEAKS
1420 void unleak_memory(const void *ptr, size_t len);
1421 #define UNLEAK(var) unleak_memory(&(var), sizeof(var))
1422 #else
1423 #define UNLEAK(var) do {} while (0)
1424 #endif
1425
1426 #define z_const
1427 #include <zlib.h>
1428
1429 #if ZLIB_VERNUM < 0x1290
1430 /*
1431  * This is uncompress2, which is only available in zlib >= 1.2.9
1432  * (released as of early 2017). See compat/zlib-uncompress2.c.
1433  */
1434 int uncompress2(Bytef *dest, uLongf *destLen, const Bytef *source,
1435                 uLong *sourceLen);
1436 #endif
1437
1438 /*
1439  * This include must come after system headers, since it introduces macros that
1440  * replace system names.
1441  */
1442 #include "banned.h"
1443
1444 /*
1445  * container_of - Get the address of an object containing a field.
1446  *
1447  * @ptr: pointer to the field.
1448  * @type: type of the object.
1449  * @member: name of the field within the object.
1450  */
1451 #define container_of(ptr, type, member) \
1452         ((type *) ((char *)(ptr) - offsetof(type, member)))
1453
1454 /*
1455  * helper function for `container_of_or_null' to avoid multiple
1456  * evaluation of @ptr
1457  */
1458 static inline void *container_of_or_null_offset(void *ptr, size_t offset)
1459 {
1460         return ptr ? (char *)ptr - offset : NULL;
1461 }
1462
1463 /*
1464  * like `container_of', but allows returned value to be NULL
1465  */
1466 #define container_of_or_null(ptr, type, member) \
1467         (type *)container_of_or_null_offset(ptr, offsetof(type, member))
1468
1469 /*
1470  * like offsetof(), but takes a pointer to a variable of type which
1471  * contains @member, instead of a specified type.
1472  * @ptr is subject to multiple evaluation since we can't rely on __typeof__
1473  * everywhere.
1474  */
1475 #if defined(__GNUC__) /* clang sets this, too */
1476 #define OFFSETOF_VAR(ptr, member) offsetof(__typeof__(*ptr), member)
1477 #else /* !__GNUC__ */
1478 #define OFFSETOF_VAR(ptr, member) \
1479         ((uintptr_t)&(ptr)->member - (uintptr_t)(ptr))
1480 #endif /* !__GNUC__ */
1481
1482 void sleep_millisec(int millisec);
1483
1484 /*
1485  * Generate len bytes from the system cryptographically secure PRNG.
1486  * Returns 0 on success and -1 on error, setting errno.  The inability to
1487  * satisfy the full request is an error.
1488  */
1489 int csprng_bytes(void *buf, size_t len);
1490
1491 #endif