2 * Author......: Jens Steube <jens.steube@gmail.com>
14 #define INCR_POS if (++rule_pos == rule_len) return (-1)
15 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
16 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
17 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
18 #define MAX_GPU_RULES 255
19 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
21 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
23 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
24 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
25 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
26 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
28 void gen_cmask (const u8
*word
, u8
*cmask
, const uint len
)
32 for (i
= 0; i
< len
; i
++)
34 if (class_alpha (word
[i
]) == 0)
49 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
50 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
52 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
53 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
54 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
56 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
57 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
58 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
60 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
64 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
69 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
73 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
78 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
82 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
87 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
92 for (l
= 0; l
< arr_len
; l
++)
98 MANGLE_SWITCH (arr
, l
, r
);
104 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
106 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
108 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
110 return (arr_len
* 2);
113 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
115 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
117 int orig_len
= arr_len
;
121 for (i
= 0; i
< times
; i
++)
123 memcpy (&arr
[arr_len
], arr
, orig_len
);
131 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
133 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
135 mangle_double (arr
, arr_len
);
137 mangle_reverse (arr
+ arr_len
, arr_len
);
139 return (arr_len
* 2);
142 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
147 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
149 MANGLE_SWITCH (arr
, l
, r
);
155 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
160 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
162 MANGLE_SWITCH (arr
, l
, r
);
168 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
170 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
174 return (arr_len
+ 1);
177 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
179 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
183 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
185 arr
[arr_pos
+ 1] = arr
[arr_pos
];
190 return (arr_len
+ 1);
193 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
195 if (upos
>= arr_len
) return (arr_len
);
199 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
201 arr
[arr_pos
] = arr
[arr_pos
+ 1];
204 return (arr_len
- 1);
207 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
209 if (upos
>= arr_len
) return (arr_len
);
211 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
215 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
217 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
223 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
225 if (upos
>= arr_len
) return (arr_len
);
227 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
231 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
233 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
236 return (arr_len
- ulen
);
239 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
241 if (upos
> arr_len
) return (arr_len
);
243 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
247 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
249 arr
[arr_pos
+ 1] = arr
[arr_pos
];
254 return (arr_len
+ 1);
257 int mangle_insert_multi (char arr
[BLOCK_SIZE
], int arr_len
, int arr_pos
, char arr2
[BLOCK_SIZE
], int arr2_len
, int arr2_pos
, int arr2_cpy
)
259 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
261 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
263 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
265 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
267 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
269 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
271 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
273 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
275 return (arr_len
+ arr2_cpy
);
278 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
280 if (upos
>= arr_len
) return (arr_len
);
287 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
289 if (upos
>= arr_len
) return (arr_len
);
291 memset (arr
+ upos
, 0, arr_len
- upos
);
296 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
300 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
302 if (arr
[arr_pos
] != oldc
) continue;
310 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
316 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
318 if (arr
[arr_pos
] == c
) continue;
320 arr
[ret_len
] = arr
[arr_pos
];
328 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
330 if (ulen
> arr_len
) return (arr_len
);
332 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
336 memcpy (cs
, arr
, ulen
);
340 for (i
= 0; i
< ulen
; i
++)
344 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
350 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
352 if (ulen
> arr_len
) return (arr_len
);
354 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
356 int upos
= arr_len
- ulen
;
360 for (i
= 0; i
< ulen
; i
++)
362 char c
= arr
[upos
+ i
];
364 arr_len
= mangle_append (arr
, arr_len
, c
);
370 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
372 if ( arr_len
== 0) return (arr_len
);
373 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
379 for (i
= 0; i
< ulen
; i
++)
381 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
387 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
389 if ( arr_len
== 0) return (arr_len
);
390 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
394 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
396 int new_pos
= arr_pos
* 2;
398 arr
[new_pos
] = arr
[arr_pos
];
400 arr
[new_pos
+ 1] = arr
[arr_pos
];
403 return (arr_len
* 2);
406 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
408 if (upos
>= arr_len
) return (arr_len
);
409 if (upos2
>= arr_len
) return (arr_len
);
411 MANGLE_SWITCH (arr
, upos
, upos2
);
416 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
418 MANGLE_SWITCH (arr
, upos
, upos2
);
423 int mangle_chr_shiftl (u8 arr
[BLOCK_SIZE
], int arr_len
, int upos
)
425 if (upos
>= arr_len
) return (arr_len
);
432 int mangle_chr_shiftr (u8 arr
[BLOCK_SIZE
], int arr_len
, int upos
)
434 if (upos
>= arr_len
) return (arr_len
);
441 int mangle_chr_incr (u8 arr
[BLOCK_SIZE
], int arr_len
, int upos
)
443 if (upos
>= arr_len
) return (arr_len
);
450 int mangle_chr_decr (u8 arr
[BLOCK_SIZE
], int arr_len
, int upos
)
452 if (upos
>= arr_len
) return (arr_len
);
459 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
465 for (pos
= 0; pos
< arr_len
; pos
++)
478 MANGLE_UPPER_AT (arr
, pos
);
482 MANGLE_LOWER_AT (arr
, pos
);
489 int generate_random_rule (char *rule_buf
, u32 rp_gen_func_min
, u32 rp_gen_func_max
)
491 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
497 for (j
= 0; j
< rp_gen_num
; j
++)
504 switch ((char) get_random_num (0, 9))
507 r
= get_random_num (0, sizeof (grp_op_nop
));
508 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
512 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
513 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
514 p1
= get_random_num (0, sizeof (grp_pos
));
515 rule_buf
[rule_pos
++] = grp_pos
[p1
];
519 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
520 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
521 p1
= get_random_num (1, 6);
522 rule_buf
[rule_pos
++] = grp_pos
[p1
];
526 r
= get_random_num (0, sizeof (grp_op_chr
));
527 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
528 p1
= get_random_num (0x20, 0x7e);
529 rule_buf
[rule_pos
++] = (char) p1
;
533 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
534 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
535 p1
= get_random_num (0x20, 0x7e);
536 rule_buf
[rule_pos
++] = (char) p1
;
537 p2
= get_random_num (0x20, 0x7e);
539 p2
= get_random_num (0x20, 0x7e);
540 rule_buf
[rule_pos
++] = (char) p2
;
544 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
545 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
546 p1
= get_random_num (0, sizeof (grp_pos
));
547 rule_buf
[rule_pos
++] = grp_pos
[p1
];
548 p2
= get_random_num (0x20, 0x7e);
549 rule_buf
[rule_pos
++] = (char) p2
;
553 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
554 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
555 p1
= get_random_num (0, sizeof (grp_pos
));
556 rule_buf
[rule_pos
++] = grp_pos
[p1
];
557 p2
= get_random_num (0, sizeof (grp_pos
));
559 p2
= get_random_num (0, sizeof (grp_pos
));
560 rule_buf
[rule_pos
++] = grp_pos
[p2
];
564 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
565 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
566 p1
= get_random_num (0, sizeof (grp_pos
));
567 rule_buf
[rule_pos
++] = grp_pos
[p1
];
568 p2
= get_random_num (1, sizeof (grp_pos
));
570 p2
= get_random_num (1, sizeof (grp_pos
));
571 rule_buf
[rule_pos
++] = grp_pos
[p2
];
575 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
576 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
577 p1
= get_random_num (0, sizeof (grp_pos
));
578 rule_buf
[rule_pos
++] = grp_pos
[p1
];
579 p2
= get_random_num (1, sizeof (grp_pos
));
580 rule_buf
[rule_pos
++] = grp_pos
[p1
];
581 p3
= get_random_num (0, sizeof (grp_pos
));
582 rule_buf
[rule_pos
++] = grp_pos
[p3
];
590 int apply_rule_cpu (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
592 char mem
[BLOCK_SIZE
];
594 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
596 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
598 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
600 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
602 int out_len
= in_len
;
603 int mem_len
= in_len
;
605 memcpy (out
, in
, out_len
);
609 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
614 switch (rule
[rule_pos
])
619 case RULE_OP_MANGLE_NOOP
:
622 case RULE_OP_MANGLE_LREST
:
623 out_len
= mangle_lrest (out
, out_len
);
626 case RULE_OP_MANGLE_UREST
:
627 out_len
= mangle_urest (out
, out_len
);
630 case RULE_OP_MANGLE_LREST_UFIRST
:
631 out_len
= mangle_lrest (out
, out_len
);
632 if (out_len
) MANGLE_UPPER_AT (out
, 0);
635 case RULE_OP_MANGLE_UREST_LFIRST
:
636 out_len
= mangle_urest (out
, out_len
);
637 if (out_len
) MANGLE_LOWER_AT (out
, 0);
640 case RULE_OP_MANGLE_TREST
:
641 out_len
= mangle_trest (out
, out_len
);
644 case RULE_OP_MANGLE_TOGGLE_AT
:
645 NEXT_RULEPOS (rule_pos
);
646 NEXT_RPTOI (rule
, rule_pos
, upos
);
647 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
650 case RULE_OP_MANGLE_REVERSE
:
651 out_len
= mangle_reverse (out
, out_len
);
654 case RULE_OP_MANGLE_DUPEWORD
:
655 out_len
= mangle_double (out
, out_len
);
658 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
659 NEXT_RULEPOS (rule_pos
);
660 NEXT_RPTOI (rule
, rule_pos
, ulen
);
661 out_len
= mangle_double_times (out
, out_len
, ulen
);
664 case RULE_OP_MANGLE_REFLECT
:
665 out_len
= mangle_reflect (out
, out_len
);
668 case RULE_OP_MANGLE_ROTATE_LEFT
:
669 mangle_rotate_left (out
, out_len
);
672 case RULE_OP_MANGLE_ROTATE_RIGHT
:
673 mangle_rotate_right (out
, out_len
);
676 case RULE_OP_MANGLE_APPEND
:
677 NEXT_RULEPOS (rule_pos
);
678 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
681 case RULE_OP_MANGLE_PREPEND
:
682 NEXT_RULEPOS (rule_pos
);
683 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
686 case RULE_OP_MANGLE_DELETE_FIRST
:
687 out_len
= mangle_delete_at (out
, out_len
, 0);
690 case RULE_OP_MANGLE_DELETE_LAST
:
691 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
694 case RULE_OP_MANGLE_DELETE_AT
:
695 NEXT_RULEPOS (rule_pos
);
696 NEXT_RPTOI (rule
, rule_pos
, upos
);
697 out_len
= mangle_delete_at (out
, out_len
, upos
);
700 case RULE_OP_MANGLE_EXTRACT
:
701 NEXT_RULEPOS (rule_pos
);
702 NEXT_RPTOI (rule
, rule_pos
, upos
);
703 NEXT_RULEPOS (rule_pos
);
704 NEXT_RPTOI (rule
, rule_pos
, ulen
);
705 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
708 case RULE_OP_MANGLE_OMIT
:
709 NEXT_RULEPOS (rule_pos
);
710 NEXT_RPTOI (rule
, rule_pos
, upos
);
711 NEXT_RULEPOS (rule_pos
);
712 NEXT_RPTOI (rule
, rule_pos
, ulen
);
713 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
716 case RULE_OP_MANGLE_INSERT
:
717 NEXT_RULEPOS (rule_pos
);
718 NEXT_RPTOI (rule
, rule_pos
, upos
);
719 NEXT_RULEPOS (rule_pos
);
720 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
723 case RULE_OP_MANGLE_OVERSTRIKE
:
724 NEXT_RULEPOS (rule_pos
);
725 NEXT_RPTOI (rule
, rule_pos
, upos
);
726 NEXT_RULEPOS (rule_pos
);
727 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
730 case RULE_OP_MANGLE_TRUNCATE_AT
:
731 NEXT_RULEPOS (rule_pos
);
732 NEXT_RPTOI (rule
, rule_pos
, upos
);
733 out_len
= mangle_truncate_at (out
, out_len
, upos
);
736 case RULE_OP_MANGLE_REPLACE
:
737 NEXT_RULEPOS (rule_pos
);
738 NEXT_RULEPOS (rule_pos
);
739 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
742 case RULE_OP_MANGLE_PURGECHAR
:
743 NEXT_RULEPOS (rule_pos
);
744 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
747 case RULE_OP_MANGLE_TOGGLECASE_REC
:
751 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
752 NEXT_RULEPOS (rule_pos
);
753 NEXT_RPTOI (rule
, rule_pos
, ulen
);
754 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
757 case RULE_OP_MANGLE_DUPECHAR_LAST
:
758 NEXT_RULEPOS (rule_pos
);
759 NEXT_RPTOI (rule
, rule_pos
, ulen
);
760 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
763 case RULE_OP_MANGLE_DUPECHAR_ALL
:
764 out_len
= mangle_dupechar (out
, out_len
);
767 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
768 NEXT_RULEPOS (rule_pos
);
769 NEXT_RPTOI (rule
, rule_pos
, ulen
);
770 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
773 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
774 NEXT_RULEPOS (rule_pos
);
775 NEXT_RPTOI (rule
, rule_pos
, ulen
);
776 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
779 case RULE_OP_MANGLE_SWITCH_FIRST
:
780 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
783 case RULE_OP_MANGLE_SWITCH_LAST
:
784 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
787 case RULE_OP_MANGLE_SWITCH_AT
:
788 NEXT_RULEPOS (rule_pos
);
789 NEXT_RPTOI (rule
, rule_pos
, upos
);
790 NEXT_RULEPOS (rule_pos
);
791 NEXT_RPTOI (rule
, rule_pos
, upos2
);
792 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
795 case RULE_OP_MANGLE_CHR_SHIFTL
:
796 NEXT_RULEPOS (rule_pos
);
797 NEXT_RPTOI (rule
, rule_pos
, upos
);
798 mangle_chr_shiftl ((u8
*) out
, out_len
, upos
);
801 case RULE_OP_MANGLE_CHR_SHIFTR
:
802 NEXT_RULEPOS (rule_pos
);
803 NEXT_RPTOI (rule
, rule_pos
, upos
);
804 mangle_chr_shiftr ((u8
*) out
, out_len
, upos
);
807 case RULE_OP_MANGLE_CHR_INCR
:
808 NEXT_RULEPOS (rule_pos
);
809 NEXT_RPTOI (rule
, rule_pos
, upos
);
810 mangle_chr_incr ((u8
*) out
, out_len
, upos
);
813 case RULE_OP_MANGLE_CHR_DECR
:
814 NEXT_RULEPOS (rule_pos
);
815 NEXT_RPTOI (rule
, rule_pos
, upos
);
816 mangle_chr_decr ((u8
*) out
, out_len
, upos
);
819 case RULE_OP_MANGLE_REPLACE_NP1
:
820 NEXT_RULEPOS (rule_pos
);
821 NEXT_RPTOI (rule
, rule_pos
, upos
);
822 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
825 case RULE_OP_MANGLE_REPLACE_NM1
:
826 NEXT_RULEPOS (rule_pos
);
827 NEXT_RPTOI (rule
, rule_pos
, upos
);
828 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
831 case RULE_OP_MANGLE_TITLE
:
832 mangle_title (out
, out_len
);
835 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
836 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
837 NEXT_RULEPOS (rule_pos
);
838 NEXT_RPTOI (rule
, rule_pos
, upos
);
839 NEXT_RULEPOS (rule_pos
);
840 NEXT_RPTOI (rule
, rule_pos
, ulen
);
841 NEXT_RULEPOS (rule_pos
);
842 NEXT_RPTOI (rule
, rule_pos
, upos2
);
843 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
846 case RULE_OP_MANGLE_APPEND_MEMORY
:
847 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
848 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
849 memcpy (out
+ out_len
, mem
, mem_len
);
853 case RULE_OP_MANGLE_PREPEND_MEMORY
:
854 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
855 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
856 memcpy (mem
+ mem_len
, out
, out_len
);
858 memcpy (out
, mem
, out_len
);
861 case RULE_OP_MEMORIZE_WORD
:
862 memcpy (mem
, out
, out_len
);
866 case RULE_OP_REJECT_LESS
:
867 NEXT_RULEPOS (rule_pos
);
868 NEXT_RPTOI (rule
, rule_pos
, upos
);
869 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
872 case RULE_OP_REJECT_GREATER
:
873 NEXT_RULEPOS (rule_pos
);
874 NEXT_RPTOI (rule
, rule_pos
, upos
);
875 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
878 case RULE_OP_REJECT_CONTAIN
:
879 NEXT_RULEPOS (rule_pos
);
880 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
883 case RULE_OP_REJECT_NOT_CONTAIN
:
884 NEXT_RULEPOS (rule_pos
);
885 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
888 case RULE_OP_REJECT_EQUAL_FIRST
:
889 NEXT_RULEPOS (rule_pos
);
890 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
893 case RULE_OP_REJECT_EQUAL_LAST
:
894 NEXT_RULEPOS (rule_pos
);
895 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
898 case RULE_OP_REJECT_EQUAL_AT
:
899 NEXT_RULEPOS (rule_pos
);
900 NEXT_RPTOI (rule
, rule_pos
, upos
);
901 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
902 NEXT_RULEPOS (rule_pos
);
903 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
906 case RULE_OP_REJECT_CONTAINS
:
907 NEXT_RULEPOS (rule_pos
);
908 NEXT_RPTOI (rule
, rule_pos
, upos
);
909 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
910 NEXT_RULEPOS (rule_pos
);
911 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
912 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
915 case RULE_OP_REJECT_MEMORY
:
916 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
920 return (RULE_RC_SYNTAX_ERROR
);
924 max_len
= (out_len
> max_len
) ? out_len
: max_len
;
927 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);
932 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
937 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_GPU_RULES
; rule_pos
++, rule_cnt
++)
939 switch (rule_buf
[rule_pos
])
945 case RULE_OP_MANGLE_NOOP
:
946 SET_NAME (rule
, rule_buf
[rule_pos
]);
949 case RULE_OP_MANGLE_LREST
:
950 SET_NAME (rule
, rule_buf
[rule_pos
]);
953 case RULE_OP_MANGLE_UREST
:
954 SET_NAME (rule
, rule_buf
[rule_pos
]);
957 case RULE_OP_MANGLE_LREST_UFIRST
:
958 SET_NAME (rule
, rule_buf
[rule_pos
]);
961 case RULE_OP_MANGLE_UREST_LFIRST
:
962 SET_NAME (rule
, rule_buf
[rule_pos
]);
965 case RULE_OP_MANGLE_TREST
:
966 SET_NAME (rule
, rule_buf
[rule_pos
]);
969 case RULE_OP_MANGLE_TOGGLE_AT
:
970 SET_NAME (rule
, rule_buf
[rule_pos
]);
971 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
974 case RULE_OP_MANGLE_REVERSE
:
975 SET_NAME (rule
, rule_buf
[rule_pos
]);
978 case RULE_OP_MANGLE_DUPEWORD
:
979 SET_NAME (rule
, rule_buf
[rule_pos
]);
982 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
983 SET_NAME (rule
, rule_buf
[rule_pos
]);
984 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
987 case RULE_OP_MANGLE_REFLECT
:
988 SET_NAME (rule
, rule_buf
[rule_pos
]);
991 case RULE_OP_MANGLE_ROTATE_LEFT
:
992 SET_NAME (rule
, rule_buf
[rule_pos
]);
995 case RULE_OP_MANGLE_ROTATE_RIGHT
:
996 SET_NAME (rule
, rule_buf
[rule_pos
]);
999 case RULE_OP_MANGLE_APPEND
:
1000 SET_NAME (rule
, rule_buf
[rule_pos
]);
1001 SET_P0 (rule
, rule_buf
[rule_pos
]);
1004 case RULE_OP_MANGLE_PREPEND
:
1005 SET_NAME (rule
, rule_buf
[rule_pos
]);
1006 SET_P0 (rule
, rule_buf
[rule_pos
]);
1009 case RULE_OP_MANGLE_DELETE_FIRST
:
1010 SET_NAME (rule
, rule_buf
[rule_pos
]);
1013 case RULE_OP_MANGLE_DELETE_LAST
:
1014 SET_NAME (rule
, rule_buf
[rule_pos
]);
1017 case RULE_OP_MANGLE_DELETE_AT
:
1018 SET_NAME (rule
, rule_buf
[rule_pos
]);
1019 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
1022 case RULE_OP_MANGLE_EXTRACT
:
1023 SET_NAME (rule
, rule_buf
[rule_pos
]);
1024 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
1025 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
1028 case RULE_OP_MANGLE_OMIT
:
1029 SET_NAME (rule
, rule_buf
[rule_pos
]);
1030 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
1031 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
1034 case RULE_OP_MANGLE_INSERT
:
1035 SET_NAME (rule
, rule_buf
[rule_pos
]);
1036 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
1037 SET_P1 (rule
, rule_buf
[rule_pos
]);
1040 case RULE_OP_MANGLE_OVERSTRIKE
:
1041 SET_NAME (rule
, rule_buf
[rule_pos
]);
1042 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
1043 SET_P1 (rule
, rule_buf
[rule_pos
]);
1046 case RULE_OP_MANGLE_TRUNCATE_AT
:
1047 SET_NAME (rule
, rule_buf
[rule_pos
]);
1048 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
1051 case RULE_OP_MANGLE_REPLACE
:
1052 SET_NAME (rule
, rule_buf
[rule_pos
]);
1053 SET_P0 (rule
, rule_buf
[rule_pos
]);
1054 SET_P1 (rule
, rule_buf
[rule_pos
]);
1057 case RULE_OP_MANGLE_PURGECHAR
:
1061 case RULE_OP_MANGLE_TOGGLECASE_REC
:
1065 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
1066 SET_NAME (rule
, rule_buf
[rule_pos
]);
1067 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
1070 case RULE_OP_MANGLE_DUPECHAR_LAST
:
1071 SET_NAME (rule
, rule_buf
[rule_pos
]);
1072 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
1075 case RULE_OP_MANGLE_DUPECHAR_ALL
:
1076 SET_NAME (rule
, rule_buf
[rule_pos
]);
1079 case RULE_OP_MANGLE_SWITCH_FIRST
:
1080 SET_NAME (rule
, rule_buf
[rule_pos
]);
1083 case RULE_OP_MANGLE_SWITCH_LAST
:
1084 SET_NAME (rule
, rule_buf
[rule_pos
]);
1087 case RULE_OP_MANGLE_SWITCH_AT
:
1088 SET_NAME (rule
, rule_buf
[rule_pos
]);
1089 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
1090 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
1093 case RULE_OP_MANGLE_CHR_SHIFTL
:
1094 SET_NAME (rule
, rule_buf
[rule_pos
]);
1095 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
1098 case RULE_OP_MANGLE_CHR_SHIFTR
:
1099 SET_NAME (rule
, rule_buf
[rule_pos
]);
1100 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
1103 case RULE_OP_MANGLE_CHR_INCR
:
1104 SET_NAME (rule
, rule_buf
[rule_pos
]);
1105 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
1108 case RULE_OP_MANGLE_CHR_DECR
:
1109 SET_NAME (rule
, rule_buf
[rule_pos
]);
1110 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
1113 case RULE_OP_MANGLE_REPLACE_NP1
:
1114 SET_NAME (rule
, rule_buf
[rule_pos
]);
1115 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
1118 case RULE_OP_MANGLE_REPLACE_NM1
:
1119 SET_NAME (rule
, rule_buf
[rule_pos
]);
1120 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
1123 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
1124 SET_NAME (rule
, rule_buf
[rule_pos
]);
1125 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
1128 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
1129 SET_NAME (rule
, rule_buf
[rule_pos
]);
1130 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
1133 case RULE_OP_MANGLE_TITLE
:
1134 SET_NAME (rule
, rule_buf
[rule_pos
]);
1143 if (rule_pos
< rule_len
) return (-1);
1152 bool class_num (char c
)
1154 return ((c
>= '0') && (c
<= '9'));
1157 bool class_lower (char c
)
1159 return ((c
>= 'a') && (c
<= 'z'));
1162 bool class_upper (char c
)
1164 return ((c
>= 'A') && (c
<= 'Z'));
1167 bool class_alpha (char c
)
1169 return (class_lower (c
) || class_upper (c
));
1172 char conv_ctoi (char c
)
1178 else if (class_upper (c
))
1180 return c
- 'A' + (char) 10;
1186 char conv_itoc (char c
)
1194 return c
+ 'A' - (char) 10;
1200 uint
get_random_num (uint min
, uint max
)
1202 if (min
== max
) return (min
);
1206 FILE *fp
= fopen("/dev/urandom", "rb");
1208 if (fp
== NULL
) exit (1);
1210 if ((fread (&data
, 1, sizeof (uint
), fp
)) != sizeof (uint
))
1217 return (uint
) ((data
% (max
- min
)) + min
);