Global Metrics

Spaces Data

Minimal test - lines (91, 98)

Code

static int internal_memcmp(const void *s1, const void *s2, size_t n) {
  const uint8_t *t1 = static_cast(s1);
  const uint8_t *t2 = static_cast(s2);
  for (size_t i = 0; i < n; ++i, ++t1, ++t2)
    if (*t1 != *t2)
      return *t1 < *t2 ? -1 : 1;
  return 0;
}

Minimal test - lines (194, 199)

Code

void *memmem(const void *s1, size_t len1, const void *s2, size_t len2) {
  ensureFuzzerInited();
  void *result = REAL(memmem)(s1, len1, s2, len2);
  __sanitizer_weak_hook_memmem(GET_CALLER_PC(), s1, len1, s2, len2, result);
  return result;
}

Minimal test - lines (206, 233)

Code

static void fuzzerInit() {
  assert(!FuzzerInitIsRunning);
  if (FuzzerInited)
    return;
  FuzzerInitIsRunning = true;

  REAL(bcmp) = reinterpret_cast(
      getFuncAddr("bcmp", reinterpret_cast(&bcmp)));
  REAL(memcmp) = reinterpret_cast(
      getFuncAddr("memcmp", reinterpret_cast(&memcmp)));
  REAL(strncmp) = reinterpret_cast(
      getFuncAddr("strncmp", reinterpret_cast(&strncmp)));
  REAL(strcmp) = reinterpret_cast(
      getFuncAddr("strcmp", reinterpret_cast(&strcmp)));
  REAL(strncasecmp) = reinterpret_cast(
      getFuncAddr("strncasecmp", reinterpret_cast(&strncasecmp)));
  REAL(strcasecmp) = reinterpret_cast(
      getFuncAddr("strcasecmp", reinterpret_cast(&strcasecmp)));
  REAL(strstr) = reinterpret_cast(
      getFuncAddr("strstr", reinterpret_cast(&strstr)));
  REAL(strcasestr) = reinterpret_cast(
      getFuncAddr("strcasestr", reinterpret_cast(&strcasestr)));
  REAL(memmem) = reinterpret_cast(
      getFuncAddr("memmem", reinterpret_cast(&memmem)));

  FuzzerInitIsRunning = false;
  FuzzerInited = 1;
}

Minimal test - lines (55, 60)

Code

static void ensureFuzzerInited() {
  assert(!FuzzerInitIsRunning);
  if (!FuzzerInited) {
    fuzzerInit();
  }
}

Minimal test - lines (140, 146)

Code

ATTRIBUTE_INTERFACE int memcmp(const void *s1, const void *s2, size_t n) {
  if (!FuzzerInited)
    return internal_memcmp(s1, s2, n);
  int result = REAL(memcmp)(s1, s2, n);
  __sanitizer_weak_hook_memcmp(GET_CALLER_PC(), s1, s2, n, result);
  return result;
}

Minimal test - lines (87, 89)

Code

static int internal_strcmp(const char *s1, const char *s2) {
  return internal_strcmp_strncmp(s1, s2, false, 0);
}

Minimal test - lines (32, 48)

Code

static void *getFuncAddr(const char *name, uintptr_t wrapper_addr) {
  void *addr = dlsym(RTLD_NEXT, name);
  if (!addr) {
    // If the lookup using RTLD_NEXT failed, the sanitizer runtime library is
    // later in the library search order than the DSO that we are trying to
    // intercept, which means that we cannot intercept this function. We still
    // want the address of the real definition, though, so look it up using
    // RTLD_DEFAULT.
    addr = dlsym(RTLD_DEFAULT, name);

    // In case `name' is not loaded, dlsym ends up finding the actual wrapper.
    // We don't want to intercept the wrapper and have it point to itself.
    if (reinterpret_cast(addr) == wrapper_addr)
      addr = nullptr;
  }
  return addr;
}

Minimal test - lines (164, 169)

Code

ATTRIBUTE_INTERFACE int strncasecmp(const char *s1, const char *s2, size_t n) {
  ensureFuzzerInited();
  int result = REAL(strncasecmp)(s1, s2, n);
  __sanitizer_weak_hook_strncasecmp(GET_CALLER_PC(), s1, s2, n, result);
  return result;
}

Minimal test - lines (107, 118)

Code

static char *internal_strstr(const char *haystack, const char *needle) {
  // This is O(N^2), but we are not using it in hot places.
  size_t len1 = internal_strlen(haystack);
  size_t len2 = internal_strlen(needle);
  if (len1 < len2)
    return nullptr;
  for (size_t pos = 0; pos <= len1 - len2; pos++) {
    if (internal_memcmp(haystack + pos, needle, len2) == 0)
      return const_cast(haystack) + pos;
  }
  return nullptr;
}

Minimal test - lines (171, 176)

Code

ATTRIBUTE_INTERFACE int strcasecmp(const char *s1, const char *s2) {
  ensureFuzzerInited();
  int result = REAL(strcasecmp)(s1, s2);
  __sanitizer_weak_hook_strcasecmp(GET_CALLER_PC(), s1, s2, result);
  return result;
}

Minimal test - lines (186, 191)

Code

ATTRIBUTE_INTERFACE char *strcasestr(const char *s1, const char *s2) {
  ensureFuzzerInited();
  char *result = REAL(strcasestr)(s1, s2);
  __sanitizer_weak_hook_strcasestr(GET_CALLER_PC(), s1, s2, result);
  return result;
}

Minimal test - lines (100, 105)

Code

static size_t internal_strlen(const char *s) {
  size_t i = 0;
  while (s[i])
    i++;
  return i;
}

Minimal test - lines (178, 184)

Code

ATTRIBUTE_INTERFACE char *strstr(const char *s1, const char *s2) {
  if (!FuzzerInited)
    return internal_strstr(s1, s2);
  char *result = REAL(strstr)(s1, s2);
  __sanitizer_weak_hook_strstr(GET_CALLER_PC(), s1, s2, result);
  return result;
}

Minimal test - lines (62, 81)

Code

static int internal_strcmp_strncmp(const char *s1, const char *s2, bool strncmp,
                                   size_t n) {
  size_t i = 0;
  while (true) {
    if (strncmp) {
      if (i == n)
        break;
      i++;
    }
    unsigned c1 = *s1;
    unsigned c2 = *s2;
    if (c1 != c2)
      return (c1 < c2) ? -1 : 1;
    if (c1 == 0)
      break;
    s1++;
    s2++;
  }
  return 0;
}

Minimal test - lines (148, 154)

Code

ATTRIBUTE_INTERFACE int strncmp(const char *s1, const char *s2, size_t n) {
  if (!FuzzerInited)
    return internal_strncmp(s1, s2, n);
  int result = REAL(strncmp)(s1, s2, n);
  __sanitizer_weak_hook_strncmp(GET_CALLER_PC(), s1, s2, n, result);
  return result;
}

Minimal test - lines (132, 138)

Code

ATTRIBUTE_INTERFACE int bcmp(const char *s1, const char *s2, size_t n) {
  if (!FuzzerInited)
    return internal_memcmp(s1, s2, n);
  int result = REAL(bcmp)(s1, s2, n);
  __sanitizer_weak_hook_memcmp(GET_CALLER_PC(), s1, s2, n, result);
  return result;
}

Minimal test - lines (83, 85)

Code

static int internal_strncmp(const char *s1, const char *s2, size_t n) {
  return internal_strcmp_strncmp(s1, s2, true, n);
}

Minimal test - lines (156, 162)

Code

ATTRIBUTE_INTERFACE int strcmp(const char *s1, const char *s2) {
  if (!FuzzerInited)
    return internal_strcmp(s1, s2);
  int result = REAL(strcmp)(s1, s2);
  __sanitizer_weak_hook_strcmp(GET_CALLER_PC(), s1, s2, result);
  return result;
}