Make calloc return NULL while initializing....

base/process_util_linux.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/process_util.h"
 
 #include <ctype.h>
 #include <dirent.h>
 #include <dlfcn.h>
 #include <errno.h>
@@ skipping 516 matching lines @@
 typedef void* (*calloc_type)(size_t nmemb, size_t size);
 typedef void* (*realloc_type)(void *ptr, size_t size);
 typedef void* (*memalign_type)(size_t boundary, size_t size);
 
 typedef int (*posix_memalign_type)(void **memptr, size_t alignment,
                                    size_t size);
 
 // Override the __libc_FOO name too.
 #define DIE_ON_OOM_1(function_name) \
   _DIE_ON_OOM_1(function_name##_type, function_name) \
-  _DIE_ON_OOM_1(function_name##_type, __libc_##function_name)
+  void* __libc_##function_name(size_t size) { \
+    return function_name(size); \
+  }
 
 #define DIE_ON_OOM_2(function_name, arg1_type) \
   _DIE_ON_OOM_2(function_name##_type, function_name, arg1_type) \
-  _DIE_ON_OOM_2(function_name##_type, __libc_##function_name, arg1_type)
-
-// posix_memalign doesn't have a __libc_ variant.
-#define DIE_ON_OOM_3INT(function_name) \
-  _DIE_ON_OOM_3INT(function_name##_type, function_name)
+  void* __libc_##function_name(arg1_type arg1, size_t size) { \
+    return function_name(arg1, size); \
+  }
 
 #define _DIE_ON_OOM_1(function_type, function_name) \
   void* function_name(size_t size) { \
     static function_type original_function = \
         reinterpret_cast<function_type>(dlsym(RTLD_NEXT, #function_name)); \
     void* ret = original_function(size); \
     if (ret == NULL && size != 0) \
       OnNoMemorySize(size); \
     return ret; \
   }
 
 #define _DIE_ON_OOM_2(function_type, function_name, arg1_type) \
   void* function_name(arg1_type arg1, size_t size) { \
     static function_type original_function = \
         reinterpret_cast<function_type>(dlsym(RTLD_NEXT, #function_name)); \
     void* ret = original_function(arg1, size); \
     if (ret == NULL && size != 0) \
       OnNoMemorySize(size); \
     return ret; \
   }
 
-#define _DIE_ON_OOM_3INT(function_type, function_name) \
-  int function_name(void** ptr, size_t alignment, size_t size) { \
-    static function_type original_function = \
-        reinterpret_cast<function_type>(dlsym(RTLD_NEXT, #function_name)); \
-    int ret = original_function(ptr, alignment, size); \
-    if (ret == ENOMEM) \
-      OnNoMemorySize(size); \
-    return ret; \
-  }
-
 DIE_ON_OOM_1(malloc)
 DIE_ON_OOM_1(valloc)
 DIE_ON_OOM_1(pvalloc)
 
-DIE_ON_OOM_2(calloc, size_t)
 DIE_ON_OOM_2(realloc, void*)
 DIE_ON_OOM_2(memalign, size_t)
 
-DIE_ON_OOM_3INT(posix_memalign)
+// dlsym uses calloc so it has to be treated specially. http://crbug.com/28244
+static void* null_calloc(size_t nmemb, size_t size) {
+  return NULL;
+}
+
+void* calloc(size_t nmemb, size_t size) {
+  static calloc_type original_function = NULL;
+  if (original_function == NULL) {
+      original_function = null_calloc;
+      original_function = reinterpret_cast<calloc_type>(dlsym(RTLD_NEXT,
+                                                              "calloc"));
+  }
+  void* ret = original_function(nmemb, size);
+  if (ret == NULL && size != 0 && original_function != null_calloc)
+    OnNoMemorySize(size);
+  return ret;
+}
+
+void* __libc_calloc(size_t nmemb, size_t size) { \
+  return calloc(nmemb, size);
+}
+
+// posix_memalign has a unique signature and doesn't have a __libc_ variant.
+int posix_memalign(void** ptr, size_t alignment, size_t size) {
+  static posix_memalign_type original_function =
+      reinterpret_cast<posix_memalign_type>(dlsym(RTLD_NEXT, "posix_memalign"));
+  int ret = original_function(ptr, alignment, size);
+  if (ret == ENOMEM)
+    OnNoMemorySize(size);
+  return ret;
+}
 
 #endif  // defined(LINUX_USE_TCMALLOC)
 
 }  // extern C
 
 void EnableTerminationOnOutOfMemory() {
   // Set the new-out of memory handler.
   std::set_new_handler(&OnNoMemory);
   // If we're using glibc's allocator, the above functions will override
   // malloc and friends and make them die on out of memory.
 #if defined(LINUX_USE_TCMALLOC)
   // For tcmalloc, we just need to tell it to behave like new.
   tc_set_new_mode(1);
 #endif
 }
 
 }  // namespace base