tools/rules_test/gpu2cpu_rule_test.c

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