[ad_1]
\n<\/p>\n
\nbut I have no knowledge of PERL at all.<\/p>\n<\/blockquote>\n
Then the solution is<\/p>\n
\n
- to hire someone who does, or<\/li>\n
- to start learning. See perl tag wiki.<\/li>\n<\/ul>\n
(As an aside, the language is called Perl<\/em>, and the interpreter used to run Perl programs is called perl<\/em>. Other capitalizations are a bit frowned upon).<\/p>\n
\nShould you decide to try solving this problem on your own, here are a few pointers:<\/p>\n
The problem can be decomposed into subproblems:<\/p>\n
\n
- \n
Parsing the rule file. This is rather easy with the
split<\/code> function.<\/p>\nThe function takes zero to three arguments: regex, string, limit. If the limit is omitted, the number of resulting fragments is arbitrary. If the string is omitted, then the
$_<\/code> special variable is used. If the regex is omitted, it will be treated as if the special value\" \"<\/code> was given: Splits on all whitespace, and removes leading whitespace.<\/p>\nTo parse a line, the following will have to be done:<\/p>\n
\n
- Removing the trailing newline with
chomp<\/code>,<\/li>\n- Splitting the line on
:<\/code> into sender and rule string, with at most two fragments,<\/li>\n- Splitting the rule string on
,<\/code> into single rules,<\/li>\n- Splitting each rule at
@<\/code> into user and domain part.<\/li>\n<\/ul>\nThe rules can then be saved in a database or a Perl data structure.<\/p>\n<\/li>\n
- \n
Matching rules given a pair of sender and receiver addresses. In case of a database, this could be done with a nice SQL query. In case of a Perl data structure, you would:<\/p>\n
\n
- retrieve all rules for the sender’s address<\/li>\n
- Iterate through all rules: Match the user and domain parts and return true once both match.<\/li>\n
- Else, return false<\/li>\n<\/ul>\n
Matching a rule against an address will first check if the rule part (user\/domain) is a
*<\/code>. Else, the parts are tested for equality. Both the user and domain part have to match for the whole rule to match.<\/p>\n<\/li>\n- \n
Choosing a good Perl data structure: To make our life easy, all email addresses and rules are only handled in their normalized form. This means e.g. lowercase. For each object in the above algorithm, one could define a seperate class. This is probably undesirable. Instead,<\/p>\n
\n
- Each rule can be represented as a 2-valued array reference<\/li>\n
- The rule list for a sender could be represented as an array reference of rules.<\/li>\n
- The association between the sender address and receiver rules can be made through a hash.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
\nCode examples<\/h2>\n
Parsing a line<\/h3>\n
where the line is given in
$_<\/code>, and a hashref$rules_for_sender<\/code> is in scope<\/p>\nchomp;\nmy ($sender, $rules) = map lc, split \/:\/, $_, 2;\nmy @rules = map [split \/@\/], split \/,\/, $rules;\n$rules_for_sender->{$sender} = \\@rules;\n<\/code><\/pre>\nIterating through all rules for a sender<\/h3>\n
for my $rule (@{ $rules->{$sender} } {\n my ($rule_user, $rule_domain) = @$rule;\n ...; # do stuff here\n}\n<\/code><\/pre>\nThe rest\u2026<\/h3>\n
\u2026is almost trivial if you remember<\/p>\n
\n
- to normalize correctly,<\/li>\n
- that
use strict; use warnings;<\/code> helps you find many errors, and<\/li>\n- that string comparision is done with the
eq<\/code> operator.<\/li>\n<\/ul>\n<\/div>\n