tools/rules_test/kernel2cpu_rule_test.c

   1 /**
   2  * Author......: Jens Steube <jens.steube@gmail.com>
   3  * License.....: MIT
   4  */
   5
   6 #define RULES_PER_PLAIN_MIN 1
   7 #define RULES_PER_PLAIN_MAX 99
   8 #define RP_GEN_FUNC_MIN     1
   9 #define RP_GEN_FUNC_MAX     4
  10 #define PW_MAX              32
  11 #define LINE_SIG_LEN        RP_GEN_FUNC_MAX * 2 + 1
  12
  13 int max_len = 0;
  14
  15 #include "cpu_rules.h"
  16 #include "rp_kernel_on_cpu.h"
  17
  18 void print_plain (char *plain, int plain_len)
  19 {
  20   int need_hexifly = 0;
  21
  22   u8 *plain_ptr = (u8*) plain;
  23
  24   int k;
  25
  26   for (k = 0; k < plain_len; k++)
  27   {
  28     if ((plain_ptr[k] < 0x20) || (plain_ptr[k] > 0x7f))
  29     {
  30       need_hexifly = 1;
  31
  32       break;
  33     }
  34   }
  35
  36   if (need_hexifly)
  37   {
  38     printf ("$HEX[");
  39
  40     for (k = 0; k < plain_len; k++)
  41     {
  42       printf ("%02x", plain_ptr[k]);
  43     }
  44
  45     printf ("]");
  46   }
  47   else
  48   {
  49     for (k = 0; k < plain_len; k++)
  50     {
  51       printf ("%c", plain_ptr[k]);
  52     }
  53   }
  54 }
  55
  56 int main (int argc, char **argv)
  57 {
  58   FILE *fp = stdin;
  59
  60   char *rule_buf = (char *) malloc (HCBUFSIZ);
  61
  62   char *line_buf = (char *) malloc (HCBUFSIZ);
  63
  64   int rp_gen_func_min = RP_GEN_FUNC_MIN;
  65   int rp_gen_func_max = RP_GEN_FUNC_MAX;
  66
  67   while (1)
  68   {
  69     /*
  70      * line
  71      */
  72
  73     if (feof (fp)) break;
  74
  75     char *line_ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
  76
  77     if (line_ptr == NULL) continue;
  78
  79     int line_len = strlen (line_ptr);
  80
  81     line_len--;
  82
  83     if (line_len <      0) continue;
  84     if (line_len > PW_MAX) continue;
  85
  86     memset (line_ptr + line_len, 0, PW_MAX - line_len);
  87
  88     /*
  89      * generate random rule and apply it afterwards
  90      */
  91
  92     uint max;
  93
  94     if (argc < 2)
  95     {
  96       max = get_random_num (RULES_PER_PLAIN_MIN, RULES_PER_PLAIN_MAX);
  97     }
  98     else
  99     {
 100       max = 1;
 101     }
 102
 103     uint i;
 104
 105     for (i = 0; i < max; i++)
 106     {
 107       int rule_len;
 108
 109       memset (rule_buf, 0, BLOCK_SIZE);
 110
 111       if (argc < 2)
 112       {
 113         rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
 114       }
 115       else
 116       {
 117         strncpy (rule_buf, argv[1], HCBUFSIZ - 1);
 118
 119         rule_len = strlen (rule_buf);
 120       }
 121
 122       kernel_rule_t kernel_rule_buf;
 123
 124       memset (&kernel_rule_buf, 0, sizeof (kernel_rule_t));
 125
 126       if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rule_buf) == -1) continue;
 127
 128       // cpu
 129       char rule_buf_cpu[BLOCK_SIZE];
 130
 131       memset (rule_buf_cpu, 0, BLOCK_SIZE);
 132
 133       max_len = 0;
 134
 135       int out_len_cpu = apply_rule_cpu (rule_buf, rule_len, line_ptr, line_len, rule_buf_cpu);
 136
 137       if (max_len >= 32) continue;
 138
 139       // gpu
 140       char rule_buf_kernel[BLOCK_SIZE];
 141
 142       memset (rule_buf_kernel, 0, sizeof (rule_buf_kernel));
 143
 144       memcpy (rule_buf_kernel, line_buf, line_len);
 145
 146       u32 *plain_ptr = (u32 *) rule_buf_kernel;
 147
 148       int out_len_kernel = apply_rules (kernel_rule_buf.cmds, &plain_ptr[0], &plain_ptr[4], line_len);
 149
 150       /*
 151        * compare
 152        */
 153
 154       if (out_len_cpu >= 0 && out_len_cpu < 32)
 155       {
 156         int failed = 1;
 157
 158         if (out_len_kernel == out_len_cpu)
 159         {
 160           if (memcmp (rule_buf_kernel, rule_buf_cpu, out_len_kernel) == 0)
 161           {
 162             failed = 0;
 163           }
 164         }
 165
 166         /*
 167          * print if failed
 168          */
 169
 170         if (failed == 1)
 171         {
 172           printf ("Rule: %s", rule_buf);
 173
 174           // nicer output
 175           int spaces = LINE_SIG_LEN - rule_len;
 176
 177           if (rule_len >  10) spaces++;
 178           if (rule_len > 100) spaces++;
 179
 180           while (spaces--) printf (".");
 181
 182           printf (": ");
 183
 184           // initial line
 185           print_plain (line_buf, line_len);
 186
 187           printf (" %i => ", line_len);
 188
 189           // modified by cpu
 190           print_plain (rule_buf_cpu, out_len_cpu);
 191
 192           printf (" %i vs ", out_len_cpu);
 193
 194           // modified by gpu
 195           print_plain (rule_buf_kernel, out_len_kernel);
 196
 197           printf (" %i\n", out_len_kernel);
 198         }
 199       }
 200     }
 201   }
 202
 203   fclose (fp);
 204
 205   free (line_buf);
 206
 207   free (rule_buf);
 208
 209   return 0;
 210 }