src/common.h

   1 /*
   2  * Copyright (C) the libgit2 contributors. All rights reserved.
   3  *
   4  * This file is part of libgit2, distributed under the GNU GPL v2 with
   5  * a Linking Exception. For full terms see the included COPYING file.
   6  */
   7 #ifndef INCLUDE_common_h__
   8 #define INCLUDE_common_h__
   9
  10 #ifndef LIBGIT2_NO_FEATURES_H
  11 # include "git2/sys/features.h"
  12 #endif
  13
  14 #include "git2/common.h"
  15 #include "cc-compat.h"
  16
  17 /** Declare a function as always inlined. */
  18 #if defined(_MSC_VER)
  19 # define GIT_INLINE(type) static __inline type
  20 #elif defined(__GNUC__)
  21 # define GIT_INLINE(type) static __inline__ type
  22 #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
  23 # define GIT_INLINE(type) static inline type
  24 #else
  25 # define GIT_INLINE(type) static type
  26 #endif
  27
  28 /** Support for gcc/clang __has_builtin intrinsic */
  29 #ifndef __has_builtin
  30 # define __has_builtin(x) 0
  31 #endif
  32
  33 /**
  34  * Declare that a function's return value must be used.
  35  *
  36  * Used mostly to guard against potential silent bugs at runtime. This is
  37  * recommended to be added to functions that:
  38  *
  39  * - Allocate / reallocate memory. This prevents memory leaks or errors where
  40  *   buffers are expected to have grown to a certain size, but could not be
  41  *   resized.
  42  * - Acquire locks. When a lock cannot be acquired, that will almost certainly
  43  *   cause a data race / undefined behavior.
  44  */
  45 #if defined(__GNUC__)
  46 # define GIT_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
  47 #else
  48 # define GIT_WARN_UNUSED_RESULT
  49 #endif
  50
  51 #include <assert.h>
  52 #include <errno.h>
  53 #include <limits.h>
  54 #include <stdlib.h>
  55 #include <stdio.h>
  56 #include <string.h>
  57
  58 #include <sys/types.h>
  59 #include <sys/stat.h>
  60
  61 #ifdef GIT_WIN32
  62
  63 # include <io.h>
  64 # include <direct.h>
  65 # include <winsock2.h>
  66 # include <windows.h>
  67 # include <ws2tcpip.h>
  68 # include "win32/msvc-compat.h"
  69 # include "win32/mingw-compat.h"
  70 # include "win32/w32_common.h"
  71 # include "win32/win32-compat.h"
  72 # include "win32/error.h"
  73 # include "win32/version.h"
  74 # ifdef GIT_THREADS
  75 #       include "win32/thread.h"
  76 # endif
  77
  78 #else
  79
  80 # include <unistd.h>
  81 # include <strings.h>
  82 # ifdef GIT_THREADS
  83 #       include <pthread.h>
  84 #       include <sched.h>
  85 # endif
  86
  87 #define GIT_LIBGIT2_CALL
  88 #define GIT_SYSTEM_CALL
  89
  90 #ifdef GIT_USE_STAT_ATIMESPEC
  91 # define st_atim st_atimespec
  92 # define st_ctim st_ctimespec
  93 # define st_mtim st_mtimespec
  94 #endif
  95
  96 # include <arpa/inet.h>
  97
  98 #endif
  99
 100 #include "git2/types.h"
 101 #include "git2/errors.h"
 102 #include "errors.h"
 103 #include "thread.h"
 104 #include "integer.h"
 105 #include "assert_safe.h"
 106 #include "utf8.h"
 107
 108 /*
 109  * Include the declarations for deprecated functions; this ensures
 110  * that they're decorated with the proper extern/visibility attributes.
 111  */
 112 #include "git2/deprecated.h"
 113
 114 #include "posix.h"
 115
 116 #define DEFAULT_BUFSIZE 65536
 117 #define FILEIO_BUFSIZE DEFAULT_BUFSIZE
 118 #define FILTERIO_BUFSIZE DEFAULT_BUFSIZE
 119 #define NETIO_BUFSIZE DEFAULT_BUFSIZE
 120
 121 /**
 122  * Check a pointer allocation result, returning -1 if it failed.
 123  */
 124 #define GIT_ERROR_CHECK_ALLOC(ptr) do { \
 125         if ((ptr) == NULL) { return -1; } \
 126         } while(0)
 127
 128 /**
 129  * Check a string buffer allocation result, returning -1 if it failed.
 130  */
 131 #define GIT_ERROR_CHECK_ALLOC_STR(buf) do { \
 132         if ((void *)(buf) == NULL || git_str_oom(buf)) { return -1; } \
 133         } while(0)
 134
 135 /**
 136  * Check a return value and propagate result if non-zero.
 137  */
 138 #define GIT_ERROR_CHECK_ERROR(code) \
 139         do { int _err = (code); if (_err) return _err; } while (0)
 140
 141 /**
 142  * Check a versioned structure for validity
 143  */
 144 GIT_INLINE(int) git_error__check_version(const void *structure, unsigned int expected_max, const char *name)
 145 {
 146         unsigned int actual;
 147
 148         if (!structure)
 149                 return 0;
 150
 151         actual = *(const unsigned int*)structure;
 152         if (actual > 0 && actual <= expected_max)
 153                 return 0;
 154
 155         git_error_set(GIT_ERROR_INVALID, "invalid version %d on %s", actual, name);
 156         return -1;
 157 }
 158 #define GIT_ERROR_CHECK_VERSION(S,V,N) if (git_error__check_version(S,V,N) < 0) return -1
 159
 160 /**
 161  * Initialize a structure with a version.
 162  */
 163 GIT_INLINE(void) git__init_structure(void *structure, size_t len, unsigned int version)
 164 {
 165         memset(structure, 0, len);
 166         *((int*)structure) = version;
 167 }
 168 #define GIT_INIT_STRUCTURE(S,V) git__init_structure(S, sizeof(*S), V)
 169
 170 #define GIT_INIT_STRUCTURE_FROM_TEMPLATE(PTR,VERSION,TYPE,TPL) do { \
 171         TYPE _tmpl = TPL; \
 172         GIT_ERROR_CHECK_VERSION(&(VERSION), _tmpl.version, #TYPE);      \
 173         memcpy((PTR), &_tmpl, sizeof(_tmpl)); } while (0)
 174
 175
 176 /** Check for additive overflow, setting an error if would occur. */
 177 #define GIT_ADD_SIZET_OVERFLOW(out, one, two) \
 178         (git__add_sizet_overflow(out, one, two) ? (git_error_set_oom(), 1) : 0)
 179
 180 /** Check for additive overflow, setting an error if would occur. */
 181 #define GIT_MULTIPLY_SIZET_OVERFLOW(out, nelem, elsize) \
 182         (git__multiply_sizet_overflow(out, nelem, elsize) ? (git_error_set_oom(), 1) : 0)
 183
 184 /** Check for additive overflow, failing if it would occur. */
 185 #define GIT_ERROR_CHECK_ALLOC_ADD(out, one, two) \
 186         if (GIT_ADD_SIZET_OVERFLOW(out, one, two)) { return -1; }
 187
 188 #define GIT_ERROR_CHECK_ALLOC_ADD3(out, one, two, three) \
 189         if (GIT_ADD_SIZET_OVERFLOW(out, one, two) || \
 190                 GIT_ADD_SIZET_OVERFLOW(out, *(out), three)) { return -1; }
 191
 192 #define GIT_ERROR_CHECK_ALLOC_ADD4(out, one, two, three, four) \
 193         if (GIT_ADD_SIZET_OVERFLOW(out, one, two) || \
 194                 GIT_ADD_SIZET_OVERFLOW(out, *(out), three) || \
 195                 GIT_ADD_SIZET_OVERFLOW(out, *(out), four)) { return -1; }
 196
 197 #define GIT_ERROR_CHECK_ALLOC_ADD5(out, one, two, three, four, five) \
 198         if (GIT_ADD_SIZET_OVERFLOW(out, one, two) || \
 199                 GIT_ADD_SIZET_OVERFLOW(out, *(out), three) || \
 200                 GIT_ADD_SIZET_OVERFLOW(out, *(out), four) || \
 201                 GIT_ADD_SIZET_OVERFLOW(out, *(out), five)) { return -1; }
 202
 203 /** Check for multiplicative overflow, failing if it would occur. */
 204 #define GIT_ERROR_CHECK_ALLOC_MULTIPLY(out, nelem, elsize) \
 205         if (GIT_MULTIPLY_SIZET_OVERFLOW(out, nelem, elsize)) { return -1; }
 206
 207 /* NOTE: other git_error functions are in the public errors.h header file */
 208
 209 /* Forward declare git_str */
 210 typedef struct git_str git_str;
 211
 212 #include "util.h"
 213
 214 #endif