lib/asan/asan_interceptors.cc

   1 //===-- asan_interceptors.cc ----------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file is a part of AddressSanitizer, an address sanity checker.
  11 //
  12 // Intercept various libc functions.
  13 //===----------------------------------------------------------------------===//
  14 #include "asan_interceptors.h"
  15
  16 #include "asan_allocator.h"
  17 #include "asan_internal.h"
  18 #include "asan_mapping.h"
  19 #include "asan_poisoning.h"
  20 #include "asan_report.h"
  21 #include "asan_stack.h"
  22 #include "asan_stats.h"
  23 #include "sanitizer_common/sanitizer_libc.h"
  24
  25 namespace __asan {
  26
  27 // Return true if we can quickly decide that the region is unpoisoned.
  28 static inline bool QuickCheckForUnpoisonedRegion(uptr beg, uptr size) {
  29   if (size == 0) return true;
  30   if (size <= 32)
  31     return !AddressIsPoisoned(beg) &&
  32            !AddressIsPoisoned(beg + size - 1) &&
  33            !AddressIsPoisoned(beg + size / 2);
  34   return false;
  35 }
  36
  37 // We implement ACCESS_MEMORY_RANGE, ASAN_READ_RANGE,
  38 // and ASAN_WRITE_RANGE as macro instead of function so
  39 // that no extra frames are created, and stack trace contains
  40 // relevant information only.
  41 // We check all shadow bytes.
  42 #define ACCESS_MEMORY_RANGE(offset, size, isWrite) do {                 \
  43     uptr __offset = (uptr)(offset);                                     \
  44     uptr __size = (uptr)(size);                                         \
  45     uptr __bad = 0;                                                     \
  46     if (!QuickCheckForUnpoisonedRegion(__offset, __size) &&             \
  47         (__bad = __asan_region_is_poisoned(__offset, __size))) {        \
  48       GET_CURRENT_PC_BP_SP;                                             \
  49       __asan_report_error(pc, bp, sp, __bad, isWrite, __size);          \
  50     }                                                                   \
  51   } while (0)
  52
  53 #define ASAN_READ_RANGE(offset, size) ACCESS_MEMORY_RANGE(offset, size, false)
  54 #define ASAN_WRITE_RANGE(offset, size) ACCESS_MEMORY_RANGE(offset, size, true)
  55
  56 // Behavior of functions like "memcpy" or "strcpy" is undefined
  57 // if memory intervals overlap. We report error in this case.
  58 // Macro is used to avoid creation of new frames.
  59 static inline bool RangesOverlap(const char *offset1, uptr length1,
  60                                  const char *offset2, uptr length2) {
  61   return !((offset1 + length1 <= offset2) || (offset2 + length2 <= offset1));
  62 }
  63 #define CHECK_RANGES_OVERLAP(name, _offset1, length1, _offset2, length2) do { \
  64   const char *offset1 = (const char*)_offset1; \
  65   const char *offset2 = (const char*)_offset2; \
  66   if (RangesOverlap(offset1, length1, offset2, length2)) { \
  67     GET_STACK_TRACE_FATAL_HERE; \
  68     ReportStringFunctionMemoryRangesOverlap(name, offset1, length1, \
  69                                             offset2, length2, &stack); \
  70   } \
  71 } while (0)
  72
  73 static inline uptr MaybeRealStrnlen(const char *s, uptr maxlen) {
  74 #if ASAN_INTERCEPT_STRNLEN
  75   if (REAL(strnlen) != 0) {
  76     return REAL(strnlen)(s, maxlen);
  77   }
  78 #endif
  79   return internal_strnlen(s, maxlen);
  80 }
  81
  82 void SetThreadName(const char *name) {
  83   AsanThread *t = GetCurrentThread();
  84   if (t)
  85     asanThreadRegistry().SetThreadName(t->tid(), name);
  86 }
  87
  88 int OnExit() {
  89   // FIXME: ask frontend whether we need to return failure.
  90   return 0;
  91 }
  92
  93 }  // namespace __asan
  94
  95 // ---------------------- Wrappers ---------------- {{{1
  96 using namespace __asan;  // NOLINT
  97
  98 DECLARE_REAL_AND_INTERCEPTOR(void *, malloc, uptr)
  99 DECLARE_REAL_AND_INTERCEPTOR(void, free, void *)
 100
 101 #if !SANITIZER_MAC
 102 #define ASAN_INTERCEPT_FUNC(name)                                        \
 103   do {                                                                   \
 104     if ((!INTERCEPT_FUNCTION(name) || !REAL(name)))                      \
 105       VReport(1, "AddressSanitizer: failed to intercept '" #name "'\n"); \
 106   } while (0)
 107 #else
 108 // OS X interceptors don't need to be initialized with INTERCEPT_FUNCTION.
 109 #define ASAN_INTERCEPT_FUNC(name)
 110 #endif  // SANITIZER_MAC
 111
 112 #define COMMON_INTERCEPT_FUNCTION(name) ASAN_INTERCEPT_FUNC(name)
 113 #define COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, size) \
 114   ASAN_WRITE_RANGE(ptr, size)
 115 #define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size) ASAN_READ_RANGE(ptr, size)
 116 #define COMMON_INTERCEPTOR_ENTER(ctx, func, ...)                       \
 117   do {                                                                 \
 118     if (asan_init_is_running) return REAL(func)(__VA_ARGS__);          \
 119     ctx = 0;                                                           \
 120     (void) ctx;                                                        \
 121     if (SANITIZER_MAC && !asan_inited) return REAL(func)(__VA_ARGS__); \
 122     ENSURE_ASAN_INITED();                                              \
 123   } while (false)
 124 #define COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd) \
 125   do {                                         \
 126   } while (false)
 127 #define COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd) \
 128   do {                                         \
 129   } while (false)
 130 #define COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, newfd) \
 131   do {                                                      \
 132   } while (false)
 133 #define COMMON_INTERCEPTOR_SET_THREAD_NAME(ctx, name) SetThreadName(name)
 134 // Should be asanThreadRegistry().SetThreadNameByUserId(thread, name)
 135 // But asan does not remember UserId's for threads (pthread_t);
 136 // and remembers all ever existed threads, so the linear search by UserId
 137 // can be slow.
 138 #define COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name) \
 139   do {                                                         \
 140   } while (false)
 141 #define COMMON_INTERCEPTOR_BLOCK_REAL(name) REAL(name)
 142 #define COMMON_INTERCEPTOR_ON_EXIT(ctx) OnExit()
 143 #include "sanitizer_common/sanitizer_common_interceptors.inc"
 144
 145 #define COMMON_SYSCALL_PRE_READ_RANGE(p, s) ASAN_READ_RANGE(p, s)
 146 #define COMMON_SYSCALL_PRE_WRITE_RANGE(p, s) ASAN_WRITE_RANGE(p, s)
 147 #define COMMON_SYSCALL_POST_READ_RANGE(p, s) \
 148   do {                                       \
 149     (void)(p);                               \
 150     (void)(s);                               \
 151   } while (false)
 152 #define COMMON_SYSCALL_POST_WRITE_RANGE(p, s) \
 153   do {                                        \
 154     (void)(p);                                \
 155     (void)(s);                                \
 156   } while (false)
 157 #include "sanitizer_common/sanitizer_common_syscalls.inc"
 158
 159 static thread_return_t THREAD_CALLING_CONV asan_thread_start(void *arg) {
 160   AsanThread *t = (AsanThread*)arg;
 161   SetCurrentThread(t);
 162   return t->ThreadStart(GetTid());
 163 }
 164
 165 #if ASAN_INTERCEPT_PTHREAD_CREATE
 166 INTERCEPTOR(int, pthread_create, void *thread,
 167     void *attr, void *(*start_routine)(void*), void *arg) {
 168   EnsureMainThreadIDIsCorrect();
 169   // Strict init-order checking in thread-hostile.
 170   if (flags()->strict_init_order)
 171     StopInitOrderChecking();
 172   GET_STACK_TRACE_THREAD;
 173   int detached = 0;
 174   if (attr != 0)
 175     REAL(pthread_attr_getdetachstate)(attr, &detached);
 176
 177   u32 current_tid = GetCurrentTidOrInvalid();
 178   AsanThread *t = AsanThread::Create(start_routine, arg);
 179   CreateThreadContextArgs args = { t, &stack };
 180   asanThreadRegistry().CreateThread(*(uptr*)t, detached, current_tid, &args);
 181   return REAL(pthread_create)(thread, attr, asan_thread_start, t);
 182 }
 183 #endif  // ASAN_INTERCEPT_PTHREAD_CREATE
 184
 185 #if ASAN_INTERCEPT_SIGNAL_AND_SIGACTION
 186
 187 #if SANITIZER_ANDROID
 188 INTERCEPTOR(void*, bsd_signal, int signum, void *handler) {
 189   if (!AsanInterceptsSignal(signum) ||
 190       common_flags()->allow_user_segv_handler) {
 191     return REAL(bsd_signal)(signum, handler);
 192   }
 193   return 0;
 194 }
 195 #else
 196 INTERCEPTOR(void*, signal, int signum, void *handler) {
 197   if (!AsanInterceptsSignal(signum) ||
 198       common_flags()->allow_user_segv_handler) {
 199     return REAL(signal)(signum, handler);
 200   }
 201   return 0;
 202 }
 203 #endif
 204
 205 INTERCEPTOR(int, sigaction, int signum, const struct sigaction *act,
 206                             struct sigaction *oldact) {
 207   if (!AsanInterceptsSignal(signum) ||
 208       common_flags()->allow_user_segv_handler) {
 209     return REAL(sigaction)(signum, act, oldact);
 210   }
 211   return 0;
 212 }
 213
 214 namespace __sanitizer {
 215 int real_sigaction(int signum, const void *act, void *oldact) {
 216   return REAL(sigaction)(signum,
 217                          (struct sigaction *)act, (struct sigaction *)oldact);
 218 }
 219 }  // namespace __sanitizer
 220
 221 #elif SANITIZER_POSIX
 222 // We need to have defined REAL(sigaction) on posix systems.
 223 DEFINE_REAL(int, sigaction, int signum, const struct sigaction *act,
 224     struct sigaction *oldact)
 225 #endif  // ASAN_INTERCEPT_SIGNAL_AND_SIGACTION
 226
 227 #if ASAN_INTERCEPT_SWAPCONTEXT
 228 static void ClearShadowMemoryForContextStack(uptr stack, uptr ssize) {
 229   // Align to page size.
 230   uptr PageSize = GetPageSizeCached();
 231   uptr bottom = stack & ~(PageSize - 1);
 232   ssize += stack - bottom;
 233   ssize = RoundUpTo(ssize, PageSize);
 234   static const uptr kMaxSaneContextStackSize = 1 << 22;  // 4 Mb
 235   if (ssize && ssize <= kMaxSaneContextStackSize) {
 236     PoisonShadow(bottom, ssize, 0);
 237   }
 238 }
 239
 240 INTERCEPTOR(int, swapcontext, struct ucontext_t *oucp,
 241             struct ucontext_t *ucp) {
 242   static bool reported_warning = false;
 243   if (!reported_warning) {
 244     Report("WARNING: ASan doesn't fully support makecontext/swapcontext "
 245            "functions and may produce false positives in some cases!\n");
 246     reported_warning = true;
 247   }
 248   // Clear shadow memory for new context (it may share stack
 249   // with current context).
 250   uptr stack, ssize;
 251   ReadContextStack(ucp, &stack, &ssize);
 252   ClearShadowMemoryForContextStack(stack, ssize);
 253   int res = REAL(swapcontext)(oucp, ucp);
 254   // swapcontext technically does not return, but program may swap context to
 255   // "oucp" later, that would look as if swapcontext() returned 0.
 256   // We need to clear shadow for ucp once again, as it may be in arbitrary
 257   // state.
 258   ClearShadowMemoryForContextStack(stack, ssize);
 259   return res;
 260 }
 261 #endif  // ASAN_INTERCEPT_SWAPCONTEXT
 262
 263 INTERCEPTOR(void, longjmp, void *env, int val) {
 264   __asan_handle_no_return();
 265   REAL(longjmp)(env, val);
 266 }
 267
 268 #if ASAN_INTERCEPT__LONGJMP
 269 INTERCEPTOR(void, _longjmp, void *env, int val) {
 270   __asan_handle_no_return();
 271   REAL(_longjmp)(env, val);
 272 }
 273 #endif
 274
 275 #if ASAN_INTERCEPT_SIGLONGJMP
 276 INTERCEPTOR(void, siglongjmp, void *env, int val) {
 277   __asan_handle_no_return();
 278   REAL(siglongjmp)(env, val);
 279 }
 280 #endif
 281
 282 #if ASAN_INTERCEPT___CXA_THROW
 283 INTERCEPTOR(void, __cxa_throw, void *a, void *b, void *c) {
 284   CHECK(REAL(__cxa_throw));
 285   __asan_handle_no_return();
 286   REAL(__cxa_throw)(a, b, c);
 287 }
 288 #endif
 289
 290 // intercept mlock and friends.
 291 // Since asan maps 16T of RAM, mlock is completely unfriendly to asan.
 292 // All functions return 0 (success).
 293 static void MlockIsUnsupported() {
 294   static bool printed = false;
 295   if (printed) return;
 296   printed = true;
 297   VPrintf(1,
 298           "INFO: AddressSanitizer ignores "
 299           "mlock/mlockall/munlock/munlockall\n");
 300 }
 301
 302 INTERCEPTOR(int, mlock, const void *addr, uptr len) {
 303   MlockIsUnsupported();
 304   return 0;
 305 }
 306
 307 INTERCEPTOR(int, munlock, const void *addr, uptr len) {
 308   MlockIsUnsupported();
 309   return 0;
 310 }
 311
 312 INTERCEPTOR(int, mlockall, int flags) {
 313   MlockIsUnsupported();
 314   return 0;
 315 }
 316
 317 INTERCEPTOR(int, munlockall, void) {
 318   MlockIsUnsupported();
 319   return 0;
 320 }
 321
 322 static inline int CharCmp(unsigned char c1, unsigned char c2) {
 323   return (c1 == c2) ? 0 : (c1 < c2) ? -1 : 1;
 324 }
 325
 326 INTERCEPTOR(int, memcmp, const void *a1, const void *a2, uptr size) {
 327   if (!asan_inited) return internal_memcmp(a1, a2, size);
 328   ENSURE_ASAN_INITED();
 329   if (flags()->replace_intrin) {
 330     if (flags()->strict_memcmp) {
 331       // Check the entire regions even if the first bytes of the buffers are
 332       // different.
 333       ASAN_READ_RANGE(a1, size);
 334       ASAN_READ_RANGE(a2, size);
 335       // Fallthrough to REAL(memcmp) below.
 336     } else {
 337       unsigned char c1 = 0, c2 = 0;
 338       const unsigned char *s1 = (const unsigned char*)a1;
 339       const unsigned char *s2 = (const unsigned char*)a2;
 340       uptr i;
 341       for (i = 0; i < size; i++) {
 342         c1 = s1[i];
 343         c2 = s2[i];
 344         if (c1 != c2) break;
 345       }
 346       ASAN_READ_RANGE(s1, Min(i + 1, size));
 347       ASAN_READ_RANGE(s2, Min(i + 1, size));
 348       return CharCmp(c1, c2);
 349     }
 350   }
 351   return REAL(memcmp(a1, a2, size));
 352 }
 353
 354 #define MEMMOVE_BODY { \
 355   if (!asan_inited) return internal_memmove(to, from, size); \
 356   if (asan_init_is_running) { \
 357     return REAL(memmove)(to, from, size); \
 358   } \
 359   ENSURE_ASAN_INITED(); \
 360   if (flags()->replace_intrin) { \
 361     ASAN_READ_RANGE(from, size); \
 362     ASAN_WRITE_RANGE(to, size); \
 363   } \
 364   return internal_memmove(to, from, size); \
 365 }
 366
 367 INTERCEPTOR(void*, memmove, void *to, const void *from, uptr size) MEMMOVE_BODY
 368
 369 INTERCEPTOR(void*, memcpy, void *to, const void *from, uptr size) {
 370 #if !SANITIZER_MAC
 371   if (!asan_inited) return internal_memcpy(to, from, size);
 372   // memcpy is called during __asan_init() from the internals
 373   // of printf(...).
 374   if (asan_init_is_running) {
 375     return REAL(memcpy)(to, from, size);
 376   }
 377   ENSURE_ASAN_INITED();
 378   if (flags()->replace_intrin) {
 379     if (to != from) {
 380       // We do not treat memcpy with to==from as a bug.
 381       // See http://llvm.org/bugs/show_bug.cgi?id=11763.
 382       CHECK_RANGES_OVERLAP("memcpy", to, size, from, size);
 383     }
 384     ASAN_READ_RANGE(from, size);
 385     ASAN_WRITE_RANGE(to, size);
 386   }
 387   return REAL(memcpy)(to, from, size);
 388 #else
 389   // At least on 10.7 and 10.8 both memcpy() and memmove() are being replaced
 390   // with WRAP(memcpy). As a result, false positives are reported for memmove()
 391   // calls. If we just disable error reporting with
 392   // ASAN_OPTIONS=replace_intrin=0, memmove() is still replaced with
 393   // internal_memcpy(), which may lead to crashes, see
 394   // http://llvm.org/bugs/show_bug.cgi?id=16362.
 395   MEMMOVE_BODY
 396 #endif  // !SANITIZER_MAC
 397 }
 398
 399 INTERCEPTOR(void*, memset, void *block, int c, uptr size) {
 400   if (!asan_inited) return internal_memset(block, c, size);
 401   // memset is called inside Printf.
 402   if (asan_init_is_running) {
 403     return REAL(memset)(block, c, size);
 404   }
 405   ENSURE_ASAN_INITED();
 406   if (flags()->replace_intrin) {
 407     ASAN_WRITE_RANGE(block, size);
 408   }
 409   return REAL(memset)(block, c, size);
 410 }
 411
 412 INTERCEPTOR(char*, strchr, const char *str, int c) {
 413   if (!asan_inited) return internal_strchr(str, c);
 414   // strchr is called inside create_purgeable_zone() when MallocGuardEdges=1 is
 415   // used.
 416   if (asan_init_is_running) {
 417     return REAL(strchr)(str, c);
 418   }
 419   ENSURE_ASAN_INITED();
 420   char *result = REAL(strchr)(str, c);
 421   if (flags()->replace_str) {
 422     uptr bytes_read = (result ? result - str : REAL(strlen)(str)) + 1;
 423     ASAN_READ_RANGE(str, bytes_read);
 424   }
 425   return result;
 426 }
 427
 428 #if ASAN_INTERCEPT_INDEX
 429 # if ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX
 430 INTERCEPTOR(char*, index, const char *string, int c)
 431   ALIAS(WRAPPER_NAME(strchr));
 432 # else
 433 #  if SANITIZER_MAC
 434 DECLARE_REAL(char*, index, const char *string, int c)
 435 OVERRIDE_FUNCTION(index, strchr);
 436 #  else
 437 DEFINE_REAL(char*, index, const char *string, int c)
 438 #  endif
 439 # endif
 440 #endif  // ASAN_INTERCEPT_INDEX
 441
 442 // For both strcat() and strncat() we need to check the validity of |to|
 443 // argument irrespective of the |from| length.
 444 INTERCEPTOR(char*, strcat, char *to, const char *from) {  // NOLINT
 445   ENSURE_ASAN_INITED();
 446   if (flags()->replace_str) {
 447     uptr from_length = REAL(strlen)(from);
 448     ASAN_READ_RANGE(from, from_length + 1);
 449     uptr to_length = REAL(strlen)(to);
 450     ASAN_READ_RANGE(to, to_length);
 451     ASAN_WRITE_RANGE(to + to_length, from_length + 1);
 452     // If the copying actually happens, the |from| string should not overlap
 453     // with the resulting string starting at |to|, which has a length of
 454     // to_length + from_length + 1.
 455     if (from_length > 0) {
 456       CHECK_RANGES_OVERLAP("strcat", to, from_length + to_length + 1,
 457                            from, from_length + 1);
 458     }
 459   }
 460   return REAL(strcat)(to, from);  // NOLINT
 461 }
 462
 463 INTERCEPTOR(char*, strncat, char *to, const char *from, uptr size) {
 464   ENSURE_ASAN_INITED();
 465   if (flags()->replace_str) {
 466     uptr from_length = MaybeRealStrnlen(from, size);
 467     uptr copy_length = Min(size, from_length + 1);
 468     ASAN_READ_RANGE(from, copy_length);
 469     uptr to_length = REAL(strlen)(to);
 470     ASAN_READ_RANGE(to, to_length);
 471     ASAN_WRITE_RANGE(to + to_length, from_length + 1);
 472     if (from_length > 0) {
 473       CHECK_RANGES_OVERLAP("strncat", to, to_length + copy_length + 1,
 474                            from, copy_length);
 475     }
 476   }
 477   return REAL(strncat)(to, from, size);
 478 }
 479
 480 INTERCEPTOR(char*, strcpy, char *to, const char *from) {  // NOLINT
 481 #if SANITIZER_MAC
 482   if (!asan_inited) return REAL(strcpy)(to, from);  // NOLINT
 483 #endif
 484   // strcpy is called from malloc_default_purgeable_zone()
 485   // in __asan::ReplaceSystemAlloc() on Mac.
 486   if (asan_init_is_running) {
 487     return REAL(strcpy)(to, from);  // NOLINT
 488   }
 489   ENSURE_ASAN_INITED();
 490   if (flags()->replace_str) {
 491     uptr from_size = REAL(strlen)(from) + 1;
 492     CHECK_RANGES_OVERLAP("strcpy", to, from_size, from, from_size);
 493     ASAN_READ_RANGE(from, from_size);
 494     ASAN_WRITE_RANGE(to, from_size);
 495   }
 496   return REAL(strcpy)(to, from);  // NOLINT
 497 }
 498
 499 #if ASAN_INTERCEPT_STRDUP
 500 INTERCEPTOR(char*, strdup, const char *s) {
 501   if (!asan_inited) return internal_strdup(s);
 502   ENSURE_ASAN_INITED();
 503   uptr length = REAL(strlen)(s);
 504   if (flags()->replace_str) {
 505     ASAN_READ_RANGE(s, length + 1);
 506   }
 507   GET_STACK_TRACE_MALLOC;
 508   void *new_mem = asan_malloc(length + 1, &stack);
 509   REAL(memcpy)(new_mem, s, length + 1);
 510   return reinterpret_cast<char*>(new_mem);
 511 }
 512 #endif
 513
 514 INTERCEPTOR(uptr, strlen, const char *s) {
 515   if (!asan_inited) return internal_strlen(s);
 516   // strlen is called from malloc_default_purgeable_zone()
 517   // in __asan::ReplaceSystemAlloc() on Mac.
 518   if (asan_init_is_running) {
 519     return REAL(strlen)(s);
 520   }
 521   ENSURE_ASAN_INITED();
 522   uptr length = REAL(strlen)(s);
 523   if (flags()->replace_str) {
 524     ASAN_READ_RANGE(s, length + 1);
 525   }
 526   return length;
 527 }
 528
 529 INTERCEPTOR(uptr, wcslen, const wchar_t *s) {
 530   uptr length = REAL(wcslen)(s);
 531   if (!asan_init_is_running) {
 532     ENSURE_ASAN_INITED();
 533     ASAN_READ_RANGE(s, (length + 1) * sizeof(wchar_t));
 534   }
 535   return length;
 536 }
 537
 538 INTERCEPTOR(char*, strncpy, char *to, const char *from, uptr size) {
 539   ENSURE_ASAN_INITED();
 540   if (flags()->replace_str) {
 541     uptr from_size = Min(size, MaybeRealStrnlen(from, size) + 1);
 542     CHECK_RANGES_OVERLAP("strncpy", to, from_size, from, from_size);
 543     ASAN_READ_RANGE(from, from_size);
 544     ASAN_WRITE_RANGE(to, size);
 545   }
 546   return REAL(strncpy)(to, from, size);
 547 }
 548
 549 #if ASAN_INTERCEPT_STRNLEN
 550 INTERCEPTOR(uptr, strnlen, const char *s, uptr maxlen) {
 551   ENSURE_ASAN_INITED();
 552   uptr length = REAL(strnlen)(s, maxlen);
 553   if (flags()->replace_str) {
 554     ASAN_READ_RANGE(s, Min(length + 1, maxlen));
 555   }
 556   return length;
 557 }
 558 #endif  // ASAN_INTERCEPT_STRNLEN
 559
 560 static inline bool IsValidStrtolBase(int base) {
 561   return (base == 0) || (2 <= base && base <= 36);
 562 }
 563
 564 static inline void FixRealStrtolEndptr(const char *nptr, char **endptr) {
 565   CHECK(endptr);
 566   if (nptr == *endptr) {
 567     // No digits were found at strtol call, we need to find out the last
 568     // symbol accessed by strtoll on our own.
 569     // We get this symbol by skipping leading blanks and optional +/- sign.
 570     while (IsSpace(*nptr)) nptr++;
 571     if (*nptr == '+' || *nptr == '-') nptr++;
 572     *endptr = (char*)nptr;
 573   }
 574   CHECK(*endptr >= nptr);
 575 }
 576
 577 INTERCEPTOR(long, strtol, const char *nptr,  // NOLINT
 578             char **endptr, int base) {
 579   ENSURE_ASAN_INITED();
 580   if (!flags()->replace_str) {
 581     return REAL(strtol)(nptr, endptr, base);
 582   }
 583   char *real_endptr;
 584   long result = REAL(strtol)(nptr, &real_endptr, base);  // NOLINT
 585   if (endptr != 0) {
 586     *endptr = real_endptr;
 587   }
 588   if (IsValidStrtolBase(base)) {
 589     FixRealStrtolEndptr(nptr, &real_endptr);
 590     ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1);
 591   }
 592   return result;
 593 }
 594
 595 INTERCEPTOR(int, atoi, const char *nptr) {
 596 #if SANITIZER_MAC
 597   if (!asan_inited) return REAL(atoi)(nptr);
 598 #endif
 599   ENSURE_ASAN_INITED();
 600   if (!flags()->replace_str) {
 601     return REAL(atoi)(nptr);
 602   }
 603   char *real_endptr;
 604   // "man atoi" tells that behavior of atoi(nptr) is the same as
 605   // strtol(nptr, 0, 10), i.e. it sets errno to ERANGE if the
 606   // parsed integer can't be stored in *long* type (even if it's
 607   // different from int). So, we just imitate this behavior.
 608   int result = REAL(strtol)(nptr, &real_endptr, 10);
 609   FixRealStrtolEndptr(nptr, &real_endptr);
 610   ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1);
 611   return result;
 612 }
 613
 614 INTERCEPTOR(long, atol, const char *nptr) {  // NOLINT
 615 #if SANITIZER_MAC
 616   if (!asan_inited) return REAL(atol)(nptr);
 617 #endif
 618   ENSURE_ASAN_INITED();
 619   if (!flags()->replace_str) {
 620     return REAL(atol)(nptr);
 621   }
 622   char *real_endptr;
 623   long result = REAL(strtol)(nptr, &real_endptr, 10);  // NOLINT
 624   FixRealStrtolEndptr(nptr, &real_endptr);
 625   ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1);
 626   return result;
 627 }
 628
 629 #if ASAN_INTERCEPT_ATOLL_AND_STRTOLL
 630 INTERCEPTOR(long long, strtoll, const char *nptr,  // NOLINT
 631             char **endptr, int base) {
 632   ENSURE_ASAN_INITED();
 633   if (!flags()->replace_str) {
 634     return REAL(strtoll)(nptr, endptr, base);
 635   }
 636   char *real_endptr;
 637   long long result = REAL(strtoll)(nptr, &real_endptr, base);  // NOLINT
 638   if (endptr != 0) {
 639     *endptr = real_endptr;
 640   }
 641   // If base has unsupported value, strtoll can exit with EINVAL
 642   // without reading any characters. So do additional checks only
 643   // if base is valid.
 644   if (IsValidStrtolBase(base)) {
 645     FixRealStrtolEndptr(nptr, &real_endptr);
 646     ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1);
 647   }
 648   return result;
 649 }
 650
 651 INTERCEPTOR(long long, atoll, const char *nptr) {  // NOLINT
 652   ENSURE_ASAN_INITED();
 653   if (!flags()->replace_str) {
 654     return REAL(atoll)(nptr);
 655   }
 656   char *real_endptr;
 657   long long result = REAL(strtoll)(nptr, &real_endptr, 10);  // NOLINT
 658   FixRealStrtolEndptr(nptr, &real_endptr);
 659   ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1);
 660   return result;
 661 }
 662 #endif  // ASAN_INTERCEPT_ATOLL_AND_STRTOLL
 663
 664 static void AtCxaAtexit(void *unused) {
 665   (void)unused;
 666   StopInitOrderChecking();
 667 }
 668
 669 #if ASAN_INTERCEPT___CXA_ATEXIT
 670 INTERCEPTOR(int, __cxa_atexit, void (*func)(void *), void *arg,
 671             void *dso_handle) {
 672 #if SANITIZER_MAC
 673   if (!asan_inited) return REAL(__cxa_atexit)(func, arg, dso_handle);
 674 #endif
 675   ENSURE_ASAN_INITED();
 676   int res = REAL(__cxa_atexit)(func, arg, dso_handle);
 677   REAL(__cxa_atexit)(AtCxaAtexit, 0, 0);
 678   return res;
 679 }
 680 #endif  // ASAN_INTERCEPT___CXA_ATEXIT
 681
 682 #if SANITIZER_WINDOWS
 683 INTERCEPTOR_WINAPI(DWORD, CreateThread,
 684                    void* security, uptr stack_size,
 685                    DWORD (__stdcall *start_routine)(void*), void* arg,
 686                    DWORD thr_flags, void* tid) {
 687   // Strict init-order checking in thread-hostile.
 688   if (flags()->strict_init_order)
 689     StopInitOrderChecking();
 690   GET_STACK_TRACE_THREAD;
 691   u32 current_tid = GetCurrentTidOrInvalid();
 692   AsanThread *t = AsanThread::Create(start_routine, arg);
 693   CreateThreadContextArgs args = { t, &stack };
 694   bool detached = false;  // FIXME: how can we determine it on Windows?
 695   asanThreadRegistry().CreateThread(*(uptr*)t, detached, current_tid, &args);
 696   return REAL(CreateThread)(security, stack_size,
 697                             asan_thread_start, t, thr_flags, tid);
 698 }
 699
 700 namespace __asan {
 701 void InitializeWindowsInterceptors() {
 702   ASAN_INTERCEPT_FUNC(CreateThread);
 703 }
 704
 705 }  // namespace __asan
 706 #endif
 707
 708 // ---------------------- InitializeAsanInterceptors ---------------- {{{1
 709 namespace __asan {
 710 void InitializeAsanInterceptors() {
 711   static bool was_called_once;
 712   CHECK(was_called_once == false);
 713   was_called_once = true;
 714   SANITIZER_COMMON_INTERCEPTORS_INIT;
 715
 716   // Intercept mem* functions.
 717   ASAN_INTERCEPT_FUNC(memcmp);
 718   ASAN_INTERCEPT_FUNC(memmove);
 719   ASAN_INTERCEPT_FUNC(memset);
 720   if (PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE) {
 721     ASAN_INTERCEPT_FUNC(memcpy);
 722   }
 723
 724   // Intercept str* functions.
 725   ASAN_INTERCEPT_FUNC(strcat);  // NOLINT
 726   ASAN_INTERCEPT_FUNC(strchr);
 727   ASAN_INTERCEPT_FUNC(strcpy);  // NOLINT
 728   ASAN_INTERCEPT_FUNC(strlen);
 729   ASAN_INTERCEPT_FUNC(wcslen);
 730   ASAN_INTERCEPT_FUNC(strncat);
 731   ASAN_INTERCEPT_FUNC(strncpy);
 732 #if ASAN_INTERCEPT_STRDUP
 733   ASAN_INTERCEPT_FUNC(strdup);
 734 #endif
 735 #if ASAN_INTERCEPT_STRNLEN
 736   ASAN_INTERCEPT_FUNC(strnlen);
 737 #endif
 738 #if ASAN_INTERCEPT_INDEX && ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX
 739   ASAN_INTERCEPT_FUNC(index);
 740 #endif
 741
 742   ASAN_INTERCEPT_FUNC(atoi);
 743   ASAN_INTERCEPT_FUNC(atol);
 744   ASAN_INTERCEPT_FUNC(strtol);
 745 #if ASAN_INTERCEPT_ATOLL_AND_STRTOLL
 746   ASAN_INTERCEPT_FUNC(atoll);
 747   ASAN_INTERCEPT_FUNC(strtoll);
 748 #endif
 749
 750 #if ASAN_INTERCEPT_MLOCKX
 751   // Intercept mlock/munlock.
 752   ASAN_INTERCEPT_FUNC(mlock);
 753   ASAN_INTERCEPT_FUNC(munlock);
 754   ASAN_INTERCEPT_FUNC(mlockall);
 755   ASAN_INTERCEPT_FUNC(munlockall);
 756 #endif
 757
 758   // Intecept signal- and jump-related functions.
 759   ASAN_INTERCEPT_FUNC(longjmp);
 760 #if ASAN_INTERCEPT_SIGNAL_AND_SIGACTION
 761   ASAN_INTERCEPT_FUNC(sigaction);
 762 #if SANITIZER_ANDROID
 763   ASAN_INTERCEPT_FUNC(bsd_signal);
 764 #else
 765   ASAN_INTERCEPT_FUNC(signal);
 766 #endif
 767 #endif
 768 #if ASAN_INTERCEPT_SWAPCONTEXT
 769   ASAN_INTERCEPT_FUNC(swapcontext);
 770 #endif
 771 #if ASAN_INTERCEPT__LONGJMP
 772   ASAN_INTERCEPT_FUNC(_longjmp);
 773 #endif
 774 #if ASAN_INTERCEPT_SIGLONGJMP
 775   ASAN_INTERCEPT_FUNC(siglongjmp);
 776 #endif
 777
 778   // Intercept exception handling functions.
 779 #if ASAN_INTERCEPT___CXA_THROW
 780   INTERCEPT_FUNCTION(__cxa_throw);
 781 #endif
 782
 783   // Intercept threading-related functions
 784 #if ASAN_INTERCEPT_PTHREAD_CREATE
 785   ASAN_INTERCEPT_FUNC(pthread_create);
 786 #endif
 787
 788   // Intercept atexit function.
 789 #if ASAN_INTERCEPT___CXA_ATEXIT
 790   ASAN_INTERCEPT_FUNC(__cxa_atexit);
 791 #endif
 792
 793   // Some Windows-specific interceptors.
 794 #if SANITIZER_WINDOWS
 795   InitializeWindowsInterceptors();
 796 #endif
 797
 798   VReport(1, "AddressSanitizer: libc interceptors initialized\n");
 799 }
 800
 801 }  // namespace __asan