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

   1 #include <ccan/tal/tal.h>
   2 #include <ccan/tal/tal.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
  22         p = tal_arr(NULL, int, (size_t)-1);
  23         ok1(!p);
  24         ok1(error_count == 1);
  25
  26         p = tal_arr(NULL, char, (size_t)-2);
  27         ok1(!p);
  28         ok1(error_count == 2);
  29
  30         /* Now try overflow cases for tal_dup. */
  31         error_count = 0;
  32         origpi = tal_arr(NULL, int, 100);
  33         ok1(origpi);
  34         ok1(error_count == 0);
  35         pi = tal_dup(NULL, int, origpi, (size_t)-1, 0);
  36         ok1(!pi);
  37         ok1(error_count == 1);
  38         pi = tal_dup(NULL, int, origpi, 0, (size_t)-1);
  39         ok1(!pi);
  40         ok1(error_count == 2);
  41
  42         pi = tal_dup(NULL, int, origpi, (size_t)-1UL / sizeof(int),
  43                      (size_t)-1UL / sizeof(int));
  44         ok1(!pi);
  45         ok1(error_count == 3);
  46         /* This will still overflow when tal_hdr is added. */
  47         pi = tal_dup(NULL, int, origpi, (size_t)-1UL / sizeof(int) / 2,
  48                      (size_t)-1UL / sizeof(int) / 2);
  49         ok1(!pi);
  50         ok1(error_count == 4);
  51         ok1(tal_first(NULL) == origpi && !tal_next(NULL, origpi));
  52         tal_free(origpi);
  53
  54         /* Now, check that with taltk() we free old one on failure. */
  55         origpi = tal_arr(NULL, int, 100);
  56         error_count = 0;
  57         pi = tal_dup(NULL, int, take(origpi), (size_t)-1, 0);
  58         ok1(!pi);
  59         ok1(error_count == 1);
  60
  61         origpi = tal_arr(NULL, int, 100);
  62         error_count = 0;
  63         pi = tal_dup(NULL, int, take(origpi), 0, (size_t)-1);
  64         ok1(!pi);
  65         ok1(error_count == 1);
  66         ok1(!tal_first(NULL));
  67
  68         origpi = tal_arr(NULL, int, 100);
  69         error_count = 0;
  70         pi = tal_dup(NULL, int, take(origpi), (size_t)-1UL / sizeof(int),
  71                      (size_t)-1UL / sizeof(int));
  72         ok1(!pi);
  73         ok1(error_count == 1);
  74         ok1(!tal_first(NULL));
  75
  76         origpi = tal_arr(NULL, int, 100);
  77         error_count = 0;
  78         /* This will still overflow when tal_hdr is added. */
  79         pi = tal_dup(NULL, int, take(origpi), (size_t)-1UL / sizeof(int) / 2,
  80                      (size_t)-1UL / sizeof(int) / 2);
  81         ok1(!pi);
  82         ok1(error_count == 1);
  83         ok1(!tal_first(NULL));
  84
  85         /* Overflow on expand addition. */
  86         cp = tal_arr(p, char, 100);
  87         ok1(!tal_expand(&cp, NULL, (size_t)-99UL));
  88         ok1(error_count == 2);
  89         tal_free(cp);
  90
  91         /* Overflow when multiplied by size */
  92         origpi = tal_arr(NULL, int, 100);
  93         ok1(!tal_expand(&origpi, NULL, (size_t)-1UL / sizeof(int)));
  94         ok1(error_count == 3);
  95         tal_free(origpi);
  96
  97         return exit_status();
  98 }