~ubuntu-branches/ubuntu/hardy/exim4/hardy-proposed

# $Cambridge: exim/exim-src/src/exipick.src,v 1.5 2005/06/07 09:15:04 ph10 Exp $

my $p_version = "20050604.1";

        Copyright (c) 2003-2005 John Jetmore <jj33\@pobox.com>

$| = 1; # unbuffer STDOUT

 

  'spool:s'     => \$G::spool,      # exim spool dir

  'bp'          => \$G::mailq_bp,   # List the queue (noop - default)

  'bpa'         => \$G::mailq_bpa,  # ... with generated address as well

  'bpc'         => \$G::mailq_bpc,  # ... but just show a count of messages

  'bpr'         => \$G::mailq_bpr,  # ... do not sort

  'bpra'        => \$G::mailq_bpra, # ... with generated addresses, unsorted

  'bpru'        => \$G::mailq_bpru, # ... only undelivered addresses, unsorted

  'bpu'         => \$G::mailq_bpu,  # ... only undelivered addresses

  'and'         => \$G::and,        # 'and' the criteria (default)

  'or'          => \$G::or,         # 'or' the criteria

  'f:s'         => \$G::qgrep_f,    # from regexp

  'r:s'         => \$G::qgrep_r,    # recipient regexp

  's:s'         => \$G::qgrep_s,    # match against size field

  'y:s'         => \$G::qgrep_y,    # message younger than (secs)

  'o:s'         => \$G::qgrep_o,    # message older than (secs)

  'z'           => \$G::qgrep_z,    # frozen only

  'x'           => \$G::qgrep_x,    # non-frozen only

  'c'           => \$G::qgrep_c,    # display match count

  'l'           => \$G::qgrep_l,    # long format (default)

  'i'           => \$G::qgrep_i,    # message ids only

  'b'           => \$G::qgrep_b,    # brief format

  'flatq'       => \$G::flatq,      # brief format

  'caseful'     => \$G::caseful,    # in '=' criteria, respect case

  'caseless'    => \$G::caseless,   #   ...ignore case (default)

  'show-vars:s' => \$G::show_vars,  # display the contents of these vars

  'show-rules'  => \$G::show_rules, # display compiled match rules

  'show-tests'  => \$G::show_tests  # display tests as applied to each message

push(@ARGV, "\$sender_address     =~ /$G::qgrep_f/") if ($G::qgrep_f);

push(@ARGV, "\$recipients         =~ /$G::qgrep_r/") if ($G::qgrep_r);

push(@ARGV, "\$shown_message_size eq $G::qgrep_s")   if ($G::qgrep_s);

push(@ARGV, "\$message_age        <  $G::qgrep_y")   if ($G::qgrep_y);

push(@ARGV, "\$message_age        >  $G::qgrep_o")   if ($G::qgrep_o);

push(@ARGV, "\$deliver_freeze")                      if ($G::qgrep_z);

push(@ARGV, "!\$deliver_freeze")                     if ($G::qgrep_x);

$G::mailq_bp        = $G::mailq_bp;        # shut up -w

$G::and             = $G::and;             # shut up -w

$G::msg_ids         = {};

$G::caseless        = $G::caseful ? 0 : 1; # nocase by default, case if both

@G::recipients_crit = ();

$spool              = $G::spool if ($G::spool);

my $count_only      = 1 if ($G::mailq_bpc || $G::qgrep_c);

my $unsorted        = 1 if ($G::mailq_bpr || $G::mailq_bpra || $G::mailq_bpru);

my $msg             = get_all_msgs($spool, $unsorted);

my $crit            = process_criteria(\@ARGV);

my $e               = Exim::SpoolFile->new();

my $tcount          = 0 if ($count_only);

my $mcount          = 0 if ($count_only);

$e->set_undelivered_only(1)      if ($G::mailq_bpru || $G::mailq_bpu);

$e->set_show_generated(1)        if ($G::mailq_bpra || $G::mailq_bpa);

$e->output_long()                if ($G::qgrep_l);

$e->output_idonly()              if ($G::qgrep_i);

$e->output_brief()               if ($G::qgrep_b);

$e->output_flatq()               if ($G::flatq);

$e->set_show_vars($G::show_vars) if ($G::show_vars);

  next if (scalar(keys(%$G::msg_ids)) && !$G::or

                                      && !$G::msg_ids->{$m->{message}});

  my @local_crit = ();

  foreach my $c (@G::recipients_crit) {              # handle each_recip* vars

    foreach my $addr (split(/, /, $e->get_var($c->{var}))) {

      my %t = ( 'cmp' => $c->{cmp}, 'var' => $c->{var} );

      $t{cmp} =~ s/"?\$var"?/'$addr'/;

      push(@local_crit, \%t);

    }

  }

  if ($G::show_tests) { print $e->get_var('message_id'), "\n"; }

  foreach my $c (@$crit, @local_crit) {

    if ($G::show_tests) {

      printf "  %25s =  '%s'\n  %25s => $ret\n",$c->{var},$var,$c->{cmp},$ret;

    }

      else        { next(MSG);      }

  next(MSG) if (scalar(@$crit, @local_crit) > 0 && !$match);

    if (/^(.*?)\s+(<=|>=|==|!=|<|>)\s+(.*)$/) {

    } elsif (/^(.*?)\s+(=~|!~)\s+(.*)$/) {

    } elsif (/^(.*?)\s+=\s+(.*)$/) {

      #print STDERR "found as bare string regexp\n";

      my $case = $G::caseful ? '' : 'i';

      push(@c, { var => lc($1), cmp => "(\"\$var\" =~ /$2/$case) ? 1 : 0" });

    } elsif (/^(.*?)\s+(eq|ne)\s+(.*)$/) {

      my $var = lc($1); my $op = $2; my $val = $3;

      $val =~ s|^(['"])(.*)\1$|$2|;

      push(@c, { var => $var, cmp => "(\"\$var\" $op \"$val\") ? 1 : 0" });

      if ($var eq 'message_id' && $op eq "eq") {

        #print STDERR "short circuit @c[-1]->{cmp} $val\n";

        $G::msg_ids->{$val} = 1;

      }

    # support the each_* psuedo variables.  Steal the criteria off of the

    # queue for special processing later

    if ($c[-1]{var} =~ /^each_(recipients(_(un)?del)?)$/) {

      my $var = $1;

      push(@G::recipients_crit,pop(@c));

      $G::recipients_crit[-1]{var} = $var; # remove each_ from the variable

    }

  if ($G::show_rules) { foreach (@c) { print "$_->{var}\t$_->{cmp}\n"; } }

 

  $self->{_show_vars}        = [];

    push(@{$self->{_show_vars}}, $v);

  return(0) if (!/^(.+)\s(\-?\d+)\s(\-?\d+)$/);

      } elsif ($tag eq '-spam_score_int') {

        $self->{_vars}{spam_score_int} = $arg;

        $self->{_vars}{spam_score}     = $arg / 10;

      } elsif ($tag eq '-bmi_verdicts') {

        $self->{_vars}{bmi_verdicts} = $arg;

      } elsif ($tag eq '-host_lookup_deferred') {

        $self->{_vars}{host_lookup_deferred} = 1;

      } elsif ($tag eq '-body_zerocount') {

        $self->{_vars}{body_zerocount} = $arg;

      } elsif ($tag eq '-allow_unqualified_recipient') {

        $self->{_vars}{allow_unqualified_recipient} = 1;

      } elsif ($tag eq '-allow_unqualified_sender') {

        $self->{_vars}{allow_unqualified_sender} = 1;

      } elsif ($tag eq '-active_hostname') {

        $self->{_vars}{smtp_active_hostname} = $arg;

      #print STDERR "exim4 #$1 style (unimplemented): $_\n";

  $self->{_vars}{recipients}         = join(', ', keys(%{$self->{_recips}}));

  $self->{_vars}{recipients_del}     = join(', ', keys(%{$self->{_del_tree}}));

  $self->{_vars}{recipients_undel}   = join(', ', keys(%{$self->{_udel_tree}}));

  $self->{_vars}{recipients_undel_count} = scalar(keys(%{$self->{_udel_tree}}));

  $self->{_vars}{recipients_del_count}   = 0;

  foreach my $r (keys %{$self->{_del_tree}}) {

    next if (!$self->{_recips}{$r});

    $self->{_vars}{recipients_del_count}++;

  }

    $self->{_vars}{message_linecount} += scalar(split(/\n/)) if ($t ne '*');

  $self->{_vars}{message_linecount} += $self->{_vars}{body_linecount};

 

  my $i = $self->{_vars}{message_size};

  if ($i == 0)              { $i = ""; }

  elsif ($i < 1024)         { $i = sprintf("%d", $i); }

  elsif ($i < 10*1024)      { $i = sprintf("%.1fK", $i / 1024); }

  elsif ($i < 1024*1024)    { $i = sprintf("%dK", ($i+512)/1024); }

  elsif ($i < 10*1024*1024) { $i = sprintf("%.1fM", $i/(1024*1024)); }

  else { $i = sprintf("%dM", ($i + 512 * 1024)/(1024*1024)); }

  $self->{_vars}{shown_message_size} = $i;

 

    print $fh $self->{_message};

    foreach my $v (@{$self->{_show_vars}}) {

      print $fh " $v='", $self->get_var($v), "'";

    }

    print $fh "\n";

    if ($self->{_output_flatq} && $self->{_show_vars}) {

        print $fh join(';',

                       map { "$_='".$self->get_var($_)."'" }

                           (@{$self->{_show_vars}})

                      );

    } else {

      printf $fh "%5s", $self->{_vars}{shown_message_size};

    }

    print $fh " ";

    foreach my $v (@{$self->{_show_vars}}) {

    if ($self->{_show_vars}) {

      print $fh " Vars: ", join(';',

                                map { "$_='".$self->get_var($_)."'" }

                                    (@{$self->{_show_vars}})

                               );

    }

exipick is designed to display the contents of a Exim mail spool based on user-specified criteria.  It is designed to mimic the output of 'exim -bp' (or any of the other -bp* options) and Exim's spec.txt should be used to learn more about the exact format of the output.  The criteria are formed by creating comparisons against characteristics of the messages, for instance $message_size, $sender_helo_name, or $message_headers.

=item --spool

 

The path to Exim's spool directory.  In general usage you should set the $spool variable in the script to your site's main spool directory (and if exipick was installed from the Exim distribution, this is done by default), but this option is useful for alternate installs, or installs on NFS servers, etc.

 

=item --and

=item --or

=item --caseful

 

By default criteria using the '=' operator are caseless.  Specifying this option make them respect case.

 

=item --show-vars <variable>[,<variable>...]

 

Cause the value of each specified variable to be displayed for every message dispayed.  For instance, the command "exipick --show-vars '$sender_ident' 'sender_host_address eq 127.0.01'" will show the ident string for every message submitted via localhost.  How exactly the variable value is diplayed changes according to what output format you specify.

 

=item --show-rules

 

If specified the internal representation of each message criteria is shown.  This is primarily used for debugging purposes.

 

==item --show-tests

 

If specified, for every message (regardless of matching criteria) the criteria's actual value is shown and the compiled internal eval is shown.  This is used primarily for debugging purposes.

 

=item --flatq

 

Change format of output so that every message is on a single line.  Useful for parsing with tools such as sed, awk, cut, etc.

 

=item -s <string>  Same as '$shown_message_size eq <string>'

 

Please see the 'exiqgrep' documentation for more details on the behaviour and output format produced by these options

The criteria are used to determine whether or not a given message should be displayed.  The criteria are built using variables containing information about the individual messages (see VARIABLES section for list and descriptions of available variables).  Each criterion is evaluated for each message in the spool and if all (by default) criteria match or (if --or option is specified) any criterion matches, the message is displayed.  See VARIABLE TYPES for explanation of types of variables and the evaluations that can be performed on them and EXAMPLES section for complete examples.

If no criteria are provided all messages in the queue are displayed (in this case the output of exipick should be identical to the output of 'exim -bp')

The numbers specified in the criteria can have a suffix of d, h, m, s, M, K, or B, in which case the number will be mulitplied by 86400, 3600, 60, 1, 1048576, 1024, or 1 respectively.  These suffixes are case sensitive.  While these are obviously designed to aid in date and size calculations, they are not restricted to variables of their respective types.  That is, though it's odd it's legal to create a criterion of a message being around for 3 kiloseconds: '$message_age >= 3K'.

Variables of the boolean type are very easy to use in criteria.  The format is either the variable by itself or the variable negated with a ! sign.  For instance, '$deliver_freeze' matches if the message in question is frozen, '!$deliver_freeze' matches if message is not frozen.

String variables are basically defined as those that are neither numeric nor boolean and can contain any data.  The string operators are =, eq, ne, =~, and !~.  With the exception of '=', the operators all match the functionality of the like-named perl operators.

 

The simplest form is a bare string regular expression, represented by the operator '='.  The value used for the comparison will be evaluated as a regular expression and can be as simple or as complex as desired.  For instance '$sender_helo_name = example' on the simple end or '$sender_helo_name = ^aol\.com$' on the more complex end.  This comparison is caseless by default, but see the --caseful option to change this.

 

Slightly more complex is the string comparison with the operators 'eq' and 'ne' for equal and not equal, respectively.  '$sender_helo_name eq hotmail.com' is true for messages with the exact helo string "hotmail.com", while '$sender_helo_name ne hotmail.com' is true for any message with a helo string other than "hotmail.com".

 

The most complex and the most flexible format are straight regular expressions with the operators '=~' and '!~'.  The value in the criteria is expected to be a correctly formatted perl regular expression B<including the regexp delimiters (usually //)>.  The criterion '$sender_helo_name !~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/' matches for any message which does not have an IP address for its helo string.

With a few exceptions the available variables match Exim's internal expansion variables in both name and exact contents.  There are a few notable additions and format deviations which are noted below.  Although a brief explanation is offered below, Exim's spec.txt should be consulted for full details.  It is important to remember that not every variable will be defined for every message.  For example, $sender_host_port is not defined for messages not received from a remote host.

In the list below, '.' denotes standard messages with contents matching Exim's variable, '#' denotes standard variables with non-standard contents, and '+' denotes a non-standard variable.

=item + $allow_unqualified_recipient

 

TRUE if unqualified recipient addresses are permitted in header lines.

 

=item + $allow_unqualified_sender

 

TRUE if unqualified sender addresses are permitted in header lines.

 

=item + $deliver_freeze

 

TRUE if the message is currently frozen.

 

=item . $first_delivery

 

TRUE if the message has never been deferred.

 

=item . $manually_thawed

=item + $dont_deliver

=item . $host_lookup_deferred

 

TRUE if there was an attempt to look up the host's name from its IP address, but an error occurred that during the attempt.

 

=item . $host_lookup_failed

 

TRUE if there was an attempt to look up the host's name from its IP address, but the attempt returned a negative result.

 

=item + $local_error_message

=item + $sender_local

=item + $sender_set_untrusted

=item . $tls_certificate_verified

=item . $body_linecount

=item . $body_zerocount

 

The number of binary zero bytes in the message's body.

 

=item + $deliver_frozen_at

=item . $interface_port

=item . $message_age

=item . $message_body_size

=item . $message_linecount

 

The number of lines in the entire message (body and headers).

 

=item . $message_size

=item . $originator_gid

=item . $originator_uid

=item . $received_count

=item . $received_time

=item . $recipients_count

 

The number of envelope recipients for the message.

 

=item + $recipients_del_count

 

The number of envelope recipients for the message which have already been delivered.  Note that this is the count of original recipients to which the message has been delivered.  It does not include generated addresses so it is possible that this number will be less than the number of addresses in the recipients_del string.

 

=item + $recipients_undel_count

 

The number of envelope recipients for the message which have not yet been delivered.

 

=item . $sender_host_port

=item + $warning_count

=item . $acl_c0-$acl_c9, $acl_m0-$acl_m9

=item . $authenticated_id

=item . $authenticated_sender

=item + $bmi_verdicts

 

I honestly don't know what the format of this variable is.  It only exists if you have Exim compiled with WITH_CONTENT_SCAN and EXPERIMENTAL_BRIGHTMAIL (and, you know, pay Symantec/Brightmail a bunch of money for the client libs and a server to use them with).

 

=item + $each_recipients

 

This is a psuedo variable which allows you to apply a criterion against each address in $recipients individually.  This allows you to create criteria against which every individual recipient is tested.  For instance, '$recipients =~ /aol.com/' will match if any of the recipient addresses contain the string "aol.com".  However, with the criterion '$each_recipients =~ /@aol.com$/', a message will only match if B<every> recipient matches that pattern.  Note that this obeys --and or --or being set.  Using it with --or is very similar to just matching against $recipients, but with the added benefit of being able to use anchors at the beginning and end of each recipient address.

 

=item + $each_recipients_del

 

Like $each_recipients, but for the $recipients_del variable.

 

=item + $each_recipients_undel

 

Like $each_recipients, but for the $recipients_undel variable.

 

=item # $header_*

=item . $interface_address

=item . $local_scan_data

=item # $message_body

=item . $message_headers

=item . $message_id

=item + $originator_login

=item . $received_protocol

=item # $recipients

=item + $recipients_del

 

The list of delivered envelope recipients for a message.  This non-standard variable is in the same format as recipients and contains the list of already-delivered recipients including any generated addresses.

 

=item + $recipients_undel

=item . $reply_address

=item . $sender_address

=item . $sender_address_domain

 

The domain part of $sender_address.

 

=item . $sender_address_local_part

 

The local part of $sender_address.

 

=item . $sender_helo_name

=item . $sender_host_address

=item . $sender_host_authenticated

=item . $sender_host_name

=item . $sender_ident

=item + $shown_message_size

 

This non-standard variable contains the formatted size string.  That is, for a message whose $message_size is 66566 bytes, $shown_message_size is 65K.

 

=item . $smtp_active_hostname

 

The value of the active host name when the message was received, as specified by the "smtp_active_hostname" option.

 

=item . $spam_score

 

The spam score of the message, for example '3.4' or '30.5'.  (Requires exiscan or WITH_CONTENT_SCAN)

 

=item . $spam_score_int

 

The spam score of the message, multiplied by ten, as an integer value.  For instance '34' or '305'.  (Requires exiscan or WITH_CONTENT_SCAN)

 

=item . $tls_cipher

=item . $tls_peerdn

=item exipick '$deliver_freeze'

=item exipick '$received_protocol eq asmtp' '$message_age < 20m'

 

Display only messages which were delivered over an authenticated smtp session in the last 20 minutes.

 

=item exipick -bpc '$message_size > 200K'

=item exipick -or '$sender_helo_name =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/' '$sender_helo_name = _'

None that I know of, except an Exim installation.  Your life will also be a lot easier if you set $spool at the top of the script to your install's spool directory (assuming this was not done automatically by the Exim install process).