Line data    Source code

       1             : #include "burp.h"
       2             : #include "alloc.h"
       3             : #include "log.h"
       4             : 
       5             : #ifdef UTEST
       6             : int alloc_errors=0;
       7             : uint64_t alloc_count=0;
       8             : uint64_t free_count=0;
       9          17 : void alloc_counters_reset(void)
      10             : {
      11          17 :         alloc_count=0;
      12          17 :         free_count=0;
      13          17 : }
      14             : 
      15           8 : static char *errored(const char *func)
      16             : {
      17           8 :         log_oom_w(__func__, func);
      18           8 :         return NULL;
      19             : }
      20             : #endif
      21             : 
      22      174423 : char *strdup_w(const char *s, const char *func)
      23             : {
      24             :         char *ret;
      25             : #ifdef UTEST
      26      174423 :         if(alloc_errors) return errored(func);
      27             : #endif
      28      174422 :         if(!(ret=strdup(s))) log_oom_w(__func__, func);
      29             : #ifdef UTEST
      30      174422 :         else alloc_count++;
      31             : #endif
      32      174422 :         return ret;
      33             : }
      34             : 
      35       90854 : void *realloc_w(void *ptr, size_t size, const char *func)
      36             : {
      37             :         void *ret;
      38             : #ifdef UTEST
      39       90854 :         int already_alloced=0;
      40       90854 :         if(alloc_errors) return errored(func);
      41       90853 :         if(ptr) already_alloced=1;
      42             : #endif
      43       90853 :         if(!(ret=realloc(ptr, size))) log_oom_w(__func__, func);
      44             : #ifdef UTEST
      45       90853 :         else if(!already_alloced) alloc_count++;
      46             : #endif
      47       90853 :         return ret;
      48             : }
      49             : 
      50      370191 : void *malloc_w(size_t size, const char *func)
      51             : {
      52             :         void *ret;
      53             : #ifdef UTEST
      54      370191 :         if(alloc_errors) return errored(func);
      55             : #endif
      56      370190 :         if(!(ret=malloc(size))) log_oom_w(__func__, func);
      57             : #ifdef UTEST
      58      370190 :         else alloc_count++;
      59             : #endif
      60      370190 :         return ret;
      61             : }
      62             : 
      63      366466 : void *calloc_w(size_t nmem, size_t size, const char *func)
      64             : {
      65             :         void *ret;
      66             : #ifdef UTEST
      67      366466 :         if(alloc_errors) return errored(func);
      68             : #endif
      69      366461 :         if(!(ret=calloc(nmem, size))) log_oom_w(__func__, func);
      70             : #ifdef UTEST
      71      366461 :         else alloc_count++;
      72             : #endif
      73      366461 :         return ret;
      74             : }
      75             : 
      76     1865315 : void free_v(void **ptr)
      77             : {
      78     3730630 :         if(!ptr || !*ptr) return;
      79      924323 :         free(*ptr);
      80      924323 :         *ptr=NULL;
      81             : #ifdef UTEST
      82      924323 :         free_count++;
      83             : #endif
      84             : }
      85             : 
      86     1427313 : void free_w(char **str)
      87             : {
      88     1427313 :         free_v((void **)str);
      89     1427313 : }