tools/rules_test/kernel2cpu_rule_test.c

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