git.ozlabs.org Git - ccan/blob - ccan/tal/talloc/test/run-overflow.c

   1 #include <ccan/tal/talloc/talloc.h>
   2 #include <ccan/tal/talloc/talloc.c>
   3 #include <ccan/tap/tap.h>
   4
   5 static int error_count;
   6
   7 static void my_error(const char *msg)
   8 {
   9         error_count++;
  10 }
  11
  12 int main(void)
  13 {
  14         void *p;
  15         int *pi, *origpi;
  16         char *cp;
  17
  18         plan_tests(30);
  19
  20         tal_set_backend(NULL, NULL, NULL, my_error);
  21         talloc_enable_null_tracking_no_autofree();
  22
  23         p = tal_arr(NULL, int, (size_t)-1);
  24         ok1(!p);
  25         ok1(error_count == 1);
  26
  27         p = tal_arr(NULL, char, (size_t)-2);
  28         ok1(!p);
  29         ok1(error_count == 2);
  30
  31         /* Now try overflow cases for tal_dup. */
  32         error_count = 0;
  33         origpi = tal_arr(NULL, int, 100);
  34         ok1(origpi);
  35         ok1(error_count == 0);
  36         pi = tal_dup_arr(NULL, int, origpi, (size_t)-1, 0);
  37         ok1(!pi);
  38         ok1(error_count == 1);
  39         pi = tal_dup_arr(NULL, int, origpi, 0, (size_t)-1);
  40         ok1(!pi);
  41         ok1(error_count == 2);
  42
  43         pi = tal_dup_arr(NULL, int, origpi, (size_t)-1UL / sizeof(int),
  44                      (size_t)-1UL / sizeof(int));
  45         ok1(!pi);
  46         ok1(error_count == 3);
  47         /* This will still overflow when tal_hdr is added. */
  48         pi = tal_dup_arr(NULL, int, origpi, (size_t)-1UL / sizeof(int) / 2,
  49                      (size_t)-1UL / sizeof(int) / 2);
  50         ok1(!pi);
  51         ok1(error_count == 4);
  52         ok1(talloc_total_blocks(NULL) == 2);
  53         tal_free(origpi);
  54
  55         /* Now, check that with taltk() we free old one on failure. */
  56         origpi = tal_arr(NULL, int, 100);
  57         error_count = 0;
  58         pi = tal_dup_arr(NULL, int, take(origpi), (size_t)-1, 0);
  59         ok1(!pi);
  60         ok1(error_count == 1);
  61
  62         origpi = tal_arr(NULL, int, 100);
  63         error_count = 0;
  64         pi = tal_dup_arr(NULL, int, take(origpi), 0, (size_t)-1);
  65         ok1(!pi);
  66         ok1(error_count == 1);
  67         ok1(talloc_total_blocks(NULL) == 1);
  68
  69         origpi = tal_arr(NULL, int, 100);
  70         error_count = 0;
  71         pi = tal_dup_arr(NULL, int, take(origpi), (size_t)-1UL / sizeof(int),
  72                      (size_t)-1UL / sizeof(int));
  73         ok1(!pi);
  74         ok1(error_count == 1);
  75         ok1(talloc_total_blocks(NULL) == 1);
  76
  77         origpi = tal_arr(NULL, int, 100);
  78         error_count = 0;
  79         /* This will still overflow when tal_hdr is added. */
  80         pi = tal_dup_arr(NULL, int, take(origpi), (size_t)-1UL / sizeof(int) / 2,
  81                      (size_t)-1UL / sizeof(int) / 2);
  82         ok1(!pi);
  83         ok1(error_count == 1);
  84         ok1(talloc_total_blocks(NULL) == 1);
  85
  86         /* Overflow on expand addition. */
  87         cp = tal_arr(p, char, 100);
  88         ok1(!tal_expand(&cp, NULL, (size_t)-99UL));
  89         ok1(error_count == 2);
  90         tal_free(cp);
  91
  92         /* Overflow when multiplied by size */
  93         origpi = tal_arr(NULL, int, 100);
  94         ok1(!tal_expand(&origpi, NULL, (size_t)-1UL / sizeof(int)));
  95         ok1(error_count == 3);
  96         tal_free(origpi);
  97
  98         talloc_disable_null_tracking();
  99         return exit_status();
 100 }